git.squeep.com Git - akkoma/blob - lib/pleroma/config/transfer_task.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Config.TransferTask do
   6   use Task
   7
   8   alias Pleroma.Config
   9   alias Pleroma.ConfigDB
  10   alias Pleroma.Repo
  11
  12   require Logger
  13
  14   @type env() :: :test | :benchmark | :dev | :prod
  15
  16   @reboot_time_keys [
  17     {:pleroma, :hackney_pools},
  18     {:pleroma, :chat},
  19     {:pleroma, Oban},
  20     {:pleroma, :rate_limit},
  21     {:pleroma, :markup},
  22     {:pleroma, :streamer},
  23     {:pleroma, :pools},
  24     {:pleroma, :connections_pool}
  25   ]
  26
  27   @reboot_time_subkeys [
  28     {:pleroma, Pleroma.Captcha, [:seconds_valid]},
  29     {:pleroma, Pleroma.Upload, [:proxy_remote]},
  30     {:pleroma, :instance, [:upload_limit]},
  31     {:pleroma, :email_notifications, [:digest]},
  32     {:pleroma, :oauth2, [:clean_expired_tokens]},
  33     {:pleroma, Pleroma.ActivityExpiration, [:enabled]},
  34     {:pleroma, Pleroma.ScheduledActivity, [:enabled]},
  35     {:pleroma, :gopher, [:enabled]}
  36   ]
  37
  38   def start_link(_) do
  39     load_and_update_env()
  40     if Config.get(:env) == :test, do: Ecto.Adapters.SQL.Sandbox.checkin(Repo)
  41     :ignore
  42   end
  43
  44   @spec load_and_update_env([ConfigDB.t()], boolean()) :: :ok
  45   def load_and_update_env(deleted_settings \\ [], restart_pleroma? \\ true) do
  46     with {_, true} <- {:configurable, Config.get(:configurable_from_database)} do
  47       # We need to restart applications for loaded settings take effect
  48
  49       {logger, other} =
  50         (Repo.all(ConfigDB) ++ deleted_settings)
  51         |> Enum.map(&transform_and_merge/1)
  52         |> Enum.split_with(fn {group, _, _, _} -> group in [:logger, :quack] end)
  53
  54       logger
  55       |> Enum.sort()
  56       |> Enum.each(&configure/1)
  57
  58       started_applications = Application.started_applications()
  59
  60       # TODO: some problem with prometheus after restart!
  61       reject = [nil, :prometheus, :postgrex]
  62
  63       reject =
  64         if restart_pleroma? do
  65           reject
  66         else
  67           [:pleroma | reject]
  68         end
  69
  70       other
  71       |> Enum.map(&update/1)
  72       |> Enum.uniq()
  73       |> Enum.reject(&(&1 in reject))
  74       |> maybe_set_pleroma_last()
  75       |> Enum.each(&restart(started_applications, &1, Config.get(:env)))
  76
  77       :ok
  78     else
  79       {:configurable, false} -> Restarter.Pleroma.rebooted()
  80     end
  81   end
  82
  83   defp maybe_set_pleroma_last(apps) do
  84     # to be ensured that pleroma will be restarted last
  85     if :pleroma in apps do
  86       apps
  87       |> List.delete(:pleroma)
  88       |> List.insert_at(-1, :pleroma)
  89     else
  90       Restarter.Pleroma.rebooted()
  91       apps
  92     end
  93   end
  94
  95   defp transform_and_merge(%{group: group, key: key, value: value} = setting) do
  96     group = ConfigDB.from_string(group)
  97     key = ConfigDB.from_string(key)
  98     value = ConfigDB.from_binary(value)
  99
 100     default = Config.Holder.default_config(group, key)
 101
 102     merged =
 103       cond do
 104         Ecto.get_meta(setting, :state) == :deleted -> default
 105         can_be_merged?(default, value) -> ConfigDB.merge_group(group, key, default, value)
 106         true -> value
 107       end
 108
 109     {group, key, value, merged}
 110   end
 111
 112   # change logger configuration in runtime, without restart
 113   defp configure({:quack, key, _, merged}) do
 114     Logger.configure_backend(Quack.Logger, [{key, merged}])
 115     :ok = update_env(:quack, key, merged)
 116   end
 117
 118   defp configure({_, :backends, _, merged}) do
 119     # removing current backends
 120     Enum.each(Application.get_env(:logger, :backends), &Logger.remove_backend/1)
 121
 122     Enum.each(merged, &Logger.add_backend/1)
 123
 124     :ok = update_env(:logger, :backends, merged)
 125   end
 126
 127   defp configure({_, key, _, merged}) when key in [:console, :ex_syslogger] do
 128     merged =
 129       if key == :console do
 130         put_in(merged[:format], merged[:format] <> "\n")
 131       else
 132         merged
 133       end
 134
 135     backend =
 136       if key == :ex_syslogger,
 137         do: {ExSyslogger, :ex_syslogger},
 138         else: key
 139
 140     Logger.configure_backend(backend, merged)
 141     :ok = update_env(:logger, key, merged)
 142   end
 143
 144   defp configure({_, key, _, merged}) do
 145     Logger.configure([{key, merged}])
 146     :ok = update_env(:logger, key, merged)
 147   end
 148
 149   defp update({group, key, value, merged}) do
 150     try do
 151       :ok = update_env(group, key, merged)
 152
 153       if group != :pleroma or pleroma_need_restart?(group, key, value), do: group
 154     rescue
 155       error ->
 156         error_msg =
 157           "updating env causes error, group: #{inspect(group)}, key: #{inspect(key)}, value: #{
 158             inspect(value)
 159           } error: #{inspect(error)}"
 160
 161         Logger.warn(error_msg)
 162
 163         nil
 164     end
 165   end
 166
 167   defp update_env(group, key, nil), do: Application.delete_env(group, key)
 168   defp update_env(group, key, value), do: Application.put_env(group, key, value)
 169
 170   @spec pleroma_need_restart?(atom(), atom(), any()) :: boolean()
 171   def pleroma_need_restart?(group, key, value) do
 172     group_and_key_need_reboot?(group, key) or group_and_subkey_need_reboot?(group, key, value)
 173   end
 174
 175   defp group_and_key_need_reboot?(group, key) do
 176     Enum.any?(@reboot_time_keys, fn {g, k} -> g == group and k == key end)
 177   end
 178
 179   defp group_and_subkey_need_reboot?(group, key, value) do
 180     Keyword.keyword?(value) and
 181       Enum.any?(@reboot_time_subkeys, fn {g, k, subkeys} ->
 182         g == group and k == key and
 183           Enum.any?(Keyword.keys(value), &(&1 in subkeys))
 184       end)
 185   end
 186
 187   defp restart(_, :pleroma, env), do: Restarter.Pleroma.restart_after_boot(env)
 188
 189   defp restart(started_applications, app, _) do
 190     with {^app, _, _} <- List.keyfind(started_applications, app, 0),
 191          :ok <- Application.stop(app) do
 192       :ok = Application.start(app)
 193     else
 194       nil ->
 195         Logger.warn("#{app} is not started.")
 196
 197       error ->
 198         error
 199         |> inspect()
 200         |> Logger.warn()
 201     end
 202   end
 203
 204   defp can_be_merged?(val1, val2) when is_list(val1) and is_list(val2) do
 205     Keyword.keyword?(val1) and Keyword.keyword?(val2)
 206   end
 207
 208   defp can_be_merged?(_val1, _val2), do: false
 209 end