X-Git-Url: https://git.squeep.com/?a=blobdiff_plain;f=lib%2Fpleroma%2Fconfig%2Ftransfer_task.ex;h=81dc847cf8e5771cb2d96b1e6c7090d72b61a5c9;hb=2144ce5188901c59cd72a0b5620862b23b47544e;hp=3214c9951281dd9ceea9847cc879900075e0f4cf;hpb=8340fe8fcce15a22e2bef9d5db41ad58c3c009e0;p=akkoma

diff --git a/lib/pleroma/config/transfer_task.ex b/lib/pleroma/config/transfer_task.ex
index 3214c9951..81dc847cf 100644
--- a/lib/pleroma/config/transfer_task.ex
+++ b/lib/pleroma/config/transfer_task.ex
@@ -1,59 +1,199 @@
 # Pleroma: A lightweight social networking server
-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.Config.TransferTask do
   use Task
-  alias Pleroma.Web.AdminAPI.Config
 
-  def start_link(_) do
-    load_and_update_env()
-    if Pleroma.Config.get(:env) == :test, do: Ecto.Adapters.SQL.Sandbox.checkin(Pleroma.Repo)
+  alias Pleroma.Config
+  alias Pleroma.ConfigDB
+  alias Pleroma.Repo
+
+  require Logger
+
+  @type env() :: :test | :benchmark | :dev | :prod
+
+  defp reboot_time_keys,
+    do: [
+      {:pleroma, Oban},
+      {:pleroma, :rate_limit},
+      {:pleroma, :markup},
+      {:pleroma, :streamer}
+    ]
+
+  defp reboot_time_subkeys,
+    do: [
+      {:pleroma, Pleroma.Captcha, [:seconds_valid]},
+      {:pleroma, Pleroma.Upload, [:proxy_remote]},
+      {:pleroma, :instance, [:upload_limit]}
+    ]
+
+  def start_link(restart_pleroma? \\ true) do
+    load_and_update_env([], restart_pleroma?)
+    if Config.get(:env) == :test, do: Ecto.Adapters.SQL.Sandbox.checkin(Repo)
     :ignore
   end
 
-  def load_and_update_env do
-    if Pleroma.Config.get([:instance, :dynamic_configuration]) and
-         Ecto.Adapters.SQL.table_exists?(Pleroma.Repo, "config") do
-      for_restart =
-        Pleroma.Repo.all(Config)
-        |> Enum.map(&update_env(&1))
-
+  @spec load_and_update_env([ConfigDB.t()], boolean()) :: :ok
+  def load_and_update_env(deleted_settings \\ [], restart_pleroma? \\ true) do
+    with {_, true} <- {:configurable, Config.get(:configurable_from_database)} do
       # We need to restart applications for loaded settings take effect
-      for_restart
-      |> Enum.reject(&(&1 in [:pleroma, :ok]))
-      |> Enum.each(fn app ->
-        Application.stop(app)
-        :ok = Application.start(app)
-      end)
-    end
-  end
+      {logger, other} =
+        (Repo.all(ConfigDB) ++ deleted_settings)
+        |> Enum.map(&merge_with_default/1)
+        |> Enum.split_with(fn {group, _, _, _} -> group in [:logger, :quack] end)
 
-  defp update_env(setting) do
-    try do
-      key =
-        if String.starts_with?(setting.key, "Pleroma.") do
-          "Elixir." <> setting.key
+      logger
+      |> Enum.sort()
+      |> Enum.each(&configure/1)
+
+      started_applications = Application.started_applications()
+
+      reject = [nil, :postgrex]
+
+      reject =
+        if restart_pleroma? do
+          reject
         else
-          String.trim_leading(setting.key, ":")
+          [:pleroma | reject]
         end
 
-      group = String.to_existing_atom(setting.group)
+      other
+      |> Enum.map(&update/1)
+      |> Enum.uniq()
+      |> Enum.reject(&(&1 in reject))
+      |> maybe_set_pleroma_last()
+      |> Enum.each(&restart(started_applications, &1, Config.get(:env)))
 
-      Application.put_env(
-        group,
-        String.to_existing_atom(key),
-        Config.from_binary(setting.value)
-      )
+      :ok
+    else
+      {:configurable, false} -> Restarter.Pleroma.rebooted()
+    end
+  end
+
+  defp maybe_set_pleroma_last(apps) do
+    # to be ensured that pleroma will be restarted last
+    if :pleroma in apps do
+      apps
+      |> List.delete(:pleroma)
+      |> List.insert_at(-1, :pleroma)
+    else
+      Restarter.Pleroma.rebooted()
+      apps
+    end
+  end
 
-      group
+  defp merge_with_default(%{group: group, key: key, value: value} = setting) do
+    default =
+      if group == :pleroma do
+        Config.get([key], Config.Holder.default_config(group, key))
+      else
+        Config.Holder.default_config(group, key)
+      end
+
+    merged =
+      cond do
+        Ecto.get_meta(setting, :state) == :deleted -> default
+        can_be_merged?(default, value) -> ConfigDB.merge_group(group, key, default, value)
+        true -> value
+      end
+
+    {group, key, value, merged}
+  end
+
+  # change logger configuration in runtime, without restart
+  defp configure({:quack, key, _, merged}) do
+    Logger.configure_backend(Quack.Logger, [{key, merged}])
+    :ok = update_env(:quack, key, merged)
+  end
+
+  defp configure({_, :backends, _, merged}) do
+    # removing current backends
+    Enum.each(Application.get_env(:logger, :backends), &Logger.remove_backend/1)
+
+    Enum.each(merged, &Logger.add_backend/1)
+
+    :ok = update_env(:logger, :backends, merged)
+  end
+
+  defp configure({_, key, _, merged}) when key in [:console, :ex_syslogger] do
+    merged =
+      if key == :console do
+        put_in(merged[:format], merged[:format] <> "\n")
+      else
+        merged
+      end
+
+    backend =
+      if key == :ex_syslogger,
+        do: {ExSyslogger, :ex_syslogger},
+        else: key
+
+    Logger.configure_backend(backend, merged)
+    :ok = update_env(:logger, key, merged)
+  end
+
+  defp configure({_, key, _, merged}) do
+    Logger.configure([{key, merged}])
+    :ok = update_env(:logger, key, merged)
+  end
+
+  defp update({group, key, value, merged}) do
+    try do
+      :ok = update_env(group, key, merged)
+
+      if group != :pleroma or pleroma_need_restart?(group, key, value), do: group
     rescue
-      e ->
-        require Logger
+      error ->
+        error_msg =
+          "updating env causes error, group: #{inspect(group)}, key: #{inspect(key)}, value: #{inspect(value)} error: #{inspect(error)}"
+
+        Logger.warn(error_msg)
+
+        nil
+    end
+  end
 
-        Logger.warn(
-          "updating env causes error, key: #{inspect(setting.key)}, error: #{inspect(e)}"
-        )
+  defp update_env(group, key, nil), do: Application.delete_env(group, key)
+  defp update_env(group, key, value), do: Application.put_env(group, key, value)
+
+  @spec pleroma_need_restart?(atom(), atom(), any()) :: boolean()
+  def pleroma_need_restart?(group, key, value) do
+    group_and_key_need_reboot?(group, key) or group_and_subkey_need_reboot?(group, key, value)
+  end
+
+  defp group_and_key_need_reboot?(group, key) do
+    Enum.any?(reboot_time_keys(), fn {g, k} -> g == group and k == key end)
+  end
+
+  defp group_and_subkey_need_reboot?(group, key, value) do
+    Keyword.keyword?(value) and
+      Enum.any?(reboot_time_subkeys(), fn {g, k, subkeys} ->
+        g == group and k == key and
+          Enum.any?(Keyword.keys(value), &(&1 in subkeys))
+      end)
+  end
+
+  defp restart(_, :pleroma, env), do: Restarter.Pleroma.restart_after_boot(env)
+
+  defp restart(started_applications, app, _) do
+    with {^app, _, _} <- List.keyfind(started_applications, app, 0),
+         :ok <- Application.stop(app) do
+      :ok = Application.start(app)
+    else
+      nil ->
+        Logger.warn("#{app} is not started.")
+
+      error ->
+        error
+        |> inspect()
+        |> Logger.warn()
     end
   end
+
+  defp can_be_merged?(val1, val2) when is_list(val1) and is_list(val2) do
+    Keyword.keyword?(val1) and Keyword.keyword?(val2)
+  end
+
+  defp can_be_merged?(_val1, _val2), do: false
 end