Merge remote-tracking branch 'remotes/origin/develop' into 1560-non-federating-instances-routes-restrictions

1 files changed, 30 insertions, 10 deletions

diff --git a/restarter/lib/pleroma.ex b/restarter/lib/pleroma.ex
index d7817909d..7f08c637c 100644
--- a/restarter/lib/pleroma.ex
+++ b/restarter/lib/pleroma.ex
@@ -3,11 +3,21 @@ defmodule Restarter.Pleroma do
 
   require Logger
 
+  @init_state %{need_reboot: false, rebooted: false, after_boot: false}
+
   def start_link(_) do
     GenServer.start_link(__MODULE__, [], name: __MODULE__)
   end
 
-  def init(_), do: {:ok, %{need_reboot?: false}}
+  def init(_), do: {:ok, @init_state}
+
+  def rebooted? do
+    GenServer.call(__MODULE__, :rebooted?)
+  end
+
+  def rebooted do
+    GenServer.cast(__MODULE__, :rebooted)
+  end
 
   def need_reboot? do
     GenServer.call(__MODULE__, :need_reboot?)
@@ -29,41 +39,51 @@ defmodule Restarter.Pleroma do
     GenServer.cast(__MODULE__, {:after_boot, env})
   end
 
+  def handle_call(:rebooted?, _from, state) do
+    {:reply, state[:rebooted], state}
+  end
+
   def handle_call(:need_reboot?, _from, state) do
-    {:reply, state[:need_reboot?], state}
+    {:reply, state[:need_reboot], state}
   end
 
-  def handle_cast(:refresh, _state) do
-    {:noreply, %{need_reboot?: false}}
+  def handle_cast(:rebooted, state) do
+    {:noreply, Map.put(state, :rebooted, true)}
   end
 
-  def handle_cast(:need_reboot, %{need_reboot?: true} = state), do: {:noreply, state}
+  def handle_cast(:need_reboot, %{need_reboot: true} = state), do: {:noreply, state}
 
   def handle_cast(:need_reboot, state) do
-    {:noreply, Map.put(state, :need_reboot?, true)}
+    {:noreply, Map.put(state, :need_reboot, true)}
+  end
+
+  def handle_cast(:refresh, _state) do
+    {:noreply, @init_state}
   end
 
   def handle_cast({:restart, :test, _}, state) do
     Logger.warn("pleroma restarted")
-    {:noreply, Map.put(state, :need_reboot?, false)}
+    {:noreply, Map.put(state, :need_reboot, false)}
   end
 
   def handle_cast({:restart, _, delay}, state) do
     Process.sleep(delay)
     do_restart(:pleroma)
-    {:noreply, Map.put(state, :need_reboot?, false)}
+    {:noreply, Map.put(state, :need_reboot, false)}
   end
 
   def handle_cast({:after_boot, _}, %{after_boot: true} = state), do: {:noreply, state}
 
   def handle_cast({:after_boot, :test}, state) do
     Logger.warn("pleroma restarted")
-    {:noreply, Map.put(state, :after_boot, true)}
+    state = %{state | after_boot: true, rebooted: true}
+    {:noreply, state}
   end
 
   def handle_cast({:after_boot, _}, state) do
     do_restart(:pleroma)
-    {:noreply, Map.put(state, :after_boot, true)}
+    state = %{state | after_boot: true, rebooted: true}
+    {:noreply, state}
   end
 
   defp do_restart(app) do