Merge branch 'restart-fix-for-mix-tasks' into 'develop'

Wait in mix task while pleroma is rebooted

See merge request pleroma/pleroma!2225

lib/mix/pleroma.ex

@@ -12,6 +12,19 @@ def start_pleroma do
     end
 
     {:ok, _} = Application.ensure_all_started(:pleroma)
+
+    if Pleroma.Config.get(:env) not in [:test, :benchmark] do
+      pleroma_rebooted?()
+    end
+  end
+
+  defp pleroma_rebooted? do
+    if Restarter.Pleroma.rebooted?() do
+      :ok
+    else
+      Process.sleep(10)
+      pleroma_rebooted?()
+    end
   end
 
   def load_pleroma do

lib/pleroma/config/transfer_task.ex

@@ -42,7 +42,8 @@ def start_link(_) do
 
   @spec load_and_update_env([ConfigDB.t()]) :: :ok | false
   def load_and_update_env(deleted \\ [], restart_pleroma? \\ true) do
-    with true <- Pleroma.Config.get(:configurable_from_database),
+    with {:configurable, true} <-
+           {:configurable, Pleroma.Config.get(:configurable_from_database)},
          true <- Ecto.Adapters.SQL.table_exists?(Repo, "config"),
          started_applications <- Application.started_applications() do
       # We need to restart applications for loaded settings take effect
@@ -65,12 +66,15 @@ def load_and_update_env(deleted \\ [], restart_pleroma? \\ true) do
         if :pleroma in applications do
           List.delete(applications, :pleroma) ++ [:pleroma]
         else
+          Restarter.Pleroma.rebooted()
           applications
         end
 
       Enum.each(applications, &restart(started_applications, &1, Pleroma.Config.get(:env)))
 
       :ok
+    else
+      {:configurable, false} -> Restarter.Pleroma.rebooted()
     end
   end
 

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 @@ def restart_after_boot(env) 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(: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, state) do
+    {:noreply, Map.put(state, :need_reboot, true)}
   end
 
   def handle_cast(:refresh, _state) do
-    {:noreply, %{need_reboot?: false}}
+    {:noreply, @init_state}
-  end
-
-  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)}
   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