Merge branch 'develop' of https://git.pleroma.social/pleroma/pleroma into develop
[akkoma] / lib / pleroma / gun / connection_pool / worker.ex
1 defmodule Pleroma.Gun.ConnectionPool.Worker do
2 alias Pleroma.Gun
3 use GenServer, restart: :temporary
4
5 @registry Pleroma.Gun.ConnectionPool
6
7 def start_link([key | _] = opts) do
8 GenServer.start_link(__MODULE__, opts, name: {:via, Registry, {@registry, key}})
9 end
10
11 @impl true
12 def init([_key, _uri, _opts, _client_pid] = opts) do
13 {:ok, nil, {:continue, {:connect, opts}}}
14 end
15
16 @impl true
17 def handle_continue({:connect, [key, uri, opts, client_pid]}, _) do
18 with {:ok, conn_pid} <- Gun.Conn.open(uri, opts),
19 Process.link(conn_pid) do
20 time = :erlang.monotonic_time(:millisecond)
21
22 {_, _} =
23 Registry.update_value(@registry, key, fn _ ->
24 {conn_pid, [client_pid], 1, time}
25 end)
26
27 send(client_pid, {:conn_pid, conn_pid})
28
29 {:noreply,
30 %{key: key, timer: nil, client_monitors: %{client_pid => Process.monitor(client_pid)}},
31 :hibernate}
32 else
33 err ->
34 {:stop, {:shutdown, err}, nil}
35 end
36 end
37
38 @impl true
39 def handle_cast({:add_client, client_pid}, state) do
40 case handle_call(:add_client, {client_pid, nil}, state) do
41 {:reply, conn_pid, state, :hibernate} ->
42 send(client_pid, {:conn_pid, conn_pid})
43 {:noreply, state, :hibernate}
44 end
45 end
46
47 @impl true
48 def handle_cast({:remove_client, client_pid}, state) do
49 case handle_call(:remove_client, {client_pid, nil}, state) do
50 {:reply, _, state, :hibernate} ->
51 {:noreply, state, :hibernate}
52 end
53 end
54
55 @impl true
56 def handle_call(:add_client, {client_pid, _}, %{key: key} = state) do
57 time = :erlang.monotonic_time(:millisecond)
58
59 {{conn_pid, _, _, _}, _} =
60 Registry.update_value(@registry, key, fn {conn_pid, used_by, crf, last_reference} ->
61 {conn_pid, [client_pid | used_by], crf(time - last_reference, crf), time}
62 end)
63
64 state =
65 if state.timer != nil do
66 Process.cancel_timer(state[:timer])
67 %{state | timer: nil}
68 else
69 state
70 end
71
72 ref = Process.monitor(client_pid)
73
74 state = put_in(state.client_monitors[client_pid], ref)
75 {:reply, conn_pid, state, :hibernate}
76 end
77
78 @impl true
79 def handle_call(:remove_client, {client_pid, _}, %{key: key} = state) do
80 {{_conn_pid, used_by, _crf, _last_reference}, _} =
81 Registry.update_value(@registry, key, fn {conn_pid, used_by, crf, last_reference} ->
82 {conn_pid, List.delete(used_by, client_pid), crf, last_reference}
83 end)
84
85 {ref, state} = pop_in(state.client_monitors[client_pid])
86 Process.demonitor(ref)
87
88 timer =
89 if used_by == [] do
90 max_idle = Pleroma.Config.get([:connections_pool, :max_idle_time], 30_000)
91 Process.send_after(self(), :idle_close, max_idle)
92 else
93 nil
94 end
95
96 {:reply, :ok, %{state | timer: timer}, :hibernate}
97 end
98
99 @impl true
100 def handle_info(:idle_close, state) do
101 # Gun monitors the owner process, and will close the connection automatically
102 # when it's terminated
103 {:stop, :normal, state}
104 end
105
106 # Gracefully shutdown if the connection got closed without any streams left
107 @impl true
108 def handle_info({:gun_down, _pid, _protocol, _reason, []}, state) do
109 {:stop, :normal, state}
110 end
111
112 # Otherwise, shutdown with an error
113 @impl true
114 def handle_info({:gun_down, _pid, _protocol, _reason, _killed_streams} = down_message, state) do
115 {:stop, {:error, down_message}, state}
116 end
117
118 @impl true
119 def handle_info({:DOWN, _ref, :process, pid, reason}, state) do
120 :telemetry.execute(
121 [:pleroma, :connection_pool, :client_death],
122 %{client_pid: pid, reason: reason},
123 %{key: state.key}
124 )
125
126 handle_cast({:remove_client, pid}, state)
127 end
128
129 # LRFU policy: https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.55.1478
130 defp crf(time_delta, prev_crf) do
131 1 + :math.pow(0.5, 0.0001 * time_delta) * prev_crf
132 end
133 end