git.squeep.com Git - akkoma/blob - lib/mix/tasks/pleroma/config.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 Mix.Tasks.Pleroma.Config do
   6   use Mix.Task
   7
   8   import Mix.Pleroma
   9
  10   alias Pleroma.ConfigDB
  11   alias Pleroma.Repo
  12
  13   @shortdoc "Manages the location of the config"
  14   @moduledoc File.read!("docs/administration/CLI_tasks/config.md")
  15
  16   def run(["migrate_to_db"]) do
  17     check_configdb(fn ->
  18       start_pleroma()
  19       migrate_to_db()
  20     end)
  21   end
  22
  23   def run(["migrate_from_db" | options]) do
  24     check_configdb(fn ->
  25       start_pleroma()
  26
  27       {opts, _} =
  28         OptionParser.parse!(options,
  29           strict: [env: :string, delete: :boolean],
  30           aliases: [d: :delete]
  31         )
  32
  33       migrate_from_db(opts)
  34     end)
  35   end
  36
  37   def run(["dump"]) do
  38     check_configdb(fn ->
  39       start_pleroma()
  40
  41       header = config_header()
  42
  43       settings =
  44         ConfigDB
  45         |> Repo.all()
  46         |> Enum.sort()
  47
  48       unless settings == [] do
  49         shell_info("#{header}")
  50
  51         settings |> Enum.each(&dump(&1))
  52       else
  53         shell_error("No settings in ConfigDB.")
  54       end
  55     end)
  56   end
  57
  58   def run(["dump", group, key]) do
  59     check_configdb(fn ->
  60       start_pleroma()
  61
  62       group = maybe_atomize(group)
  63       key = maybe_atomize(key)
  64
  65       group
  66       |> ConfigDB.get_all_by_group_and_key(key)
  67       |> Enum.each(&dump/1)
  68     end)
  69   end
  70
  71   def run(["dump", group]) do
  72     check_configdb(fn ->
  73       start_pleroma()
  74
  75       group = maybe_atomize(group)
  76
  77       dump_group(group)
  78     end)
  79   end
  80
  81   def run(["groups"]) do
  82     check_configdb(fn ->
  83       start_pleroma()
  84
  85       groups =
  86         ConfigDB
  87         |> Repo.all()
  88         |> Enum.map(fn x -> x.group end)
  89         |> Enum.sort()
  90         |> Enum.uniq()
  91
  92       if length(groups) > 0 do
  93         shell_info("The following configuration groups are set in ConfigDB:\r\n")
  94         groups |> Enum.each(fn x -> shell_info("-  #{x}") end)
  95         shell_info("\r\n")
  96       end
  97     end)
  98   end
  99
 100   def run(["reset", "--force"]) do
 101     check_configdb(fn ->
 102       start_pleroma()
 103       truncatedb()
 104       shell_info("The ConfigDB settings have been removed from the database.")
 105     end)
 106   end
 107
 108   def run(["reset"]) do
 109     check_configdb(fn ->
 110       start_pleroma()
 111
 112       shell_info("The following settings will be permanently removed:")
 113
 114       ConfigDB
 115       |> Repo.all()
 116       |> Enum.sort()
 117       |> Enum.each(&dump(&1))
 118
 119       shell_error("\nTHIS CANNOT BE UNDONE!")
 120
 121       if shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
 122         truncatedb()
 123
 124         shell_info("The ConfigDB settings have been removed from the database.")
 125       else
 126         shell_error("No changes made.")
 127       end
 128     end)
 129   end
 130
 131   def run(["delete", "--force", group, key]) do
 132     start_pleroma()
 133
 134     group = maybe_atomize(group)
 135     key = maybe_atomize(key)
 136
 137     delete_key(group, key)
 138   end
 139
 140   def run(["delete", "--force", group]) do
 141     start_pleroma()
 142
 143     group = maybe_atomize(group)
 144
 145     delete_group(group)
 146   end
 147
 148   def run(["delete", group, key]) do
 149     start_pleroma()
 150
 151     group = maybe_atomize(group)
 152     key = maybe_atomize(key)
 153
 154     if shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
 155       delete_key(group, key)
 156     else
 157       shell_error("No changes made.")
 158     end
 159   end
 160
 161   def run(["delete", group]) do
 162     start_pleroma()
 163
 164     group = maybe_atomize(group)
 165
 166     if shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
 167       delete_group(group)
 168     else
 169       shell_error("No changes made.")
 170     end
 171   end
 172
 173   @spec migrate_to_db(Path.t() | nil) :: any()
 174   def migrate_to_db(file_path \\ nil) do
 175     with :ok <- Pleroma.Config.DeprecationWarnings.warn() do
 176       config_file =
 177         if file_path do
 178           file_path
 179         else
 180           if Pleroma.Config.get(:release) do
 181             Pleroma.Config.get(:config_path)
 182           else
 183             "config/#{Pleroma.Config.get(:env)}.secret.exs"
 184           end
 185         end
 186
 187       do_migrate_to_db(config_file)
 188     else
 189       _ ->
 190         shell_error("Migration is not allowed until all deprecation warnings have been resolved.")
 191     end
 192   end
 193
 194   defp do_migrate_to_db(config_file) do
 195     if File.exists?(config_file) do
 196       shell_info("Migrating settings from file: #{Path.expand(config_file)}")
 197       truncatedb()
 198
 199       custom_config =
 200         config_file
 201         |> read_file()
 202         |> elem(0)
 203
 204       custom_config
 205       |> Keyword.keys()
 206       |> Enum.each(&create(&1, custom_config))
 207     else
 208       shell_info("To migrate settings, you must define custom settings in #{config_file}.")
 209     end
 210   end
 211
 212   defp create(group, settings) do
 213     group
 214     |> Pleroma.Config.Loader.filter_group(settings)
 215     |> Enum.each(fn {key, value} ->
 216       {:ok, _} = ConfigDB.update_or_create(%{group: group, key: key, value: value})
 217
 218       shell_info("Settings for key #{key} migrated.")
 219     end)
 220
 221     shell_info("Settings for group #{inspect(group)} migrated.")
 222   end
 223
 224   defp migrate_from_db(opts) do
 225     env = opts[:env] || Pleroma.Config.get(:env)
 226
 227     config_path =
 228       if Pleroma.Config.get(:release) do
 229         :config_path
 230         |> Pleroma.Config.get()
 231         |> Path.dirname()
 232       else
 233         "config"
 234       end
 235       |> Path.join("#{env}.exported_from_db.secret.exs")
 236
 237     file = File.open!(config_path, [:write, :utf8])
 238
 239     IO.write(file, config_header())
 240
 241     ConfigDB
 242     |> Repo.all()
 243     |> Enum.each(&write_and_delete(&1, file, opts[:delete]))
 244
 245     :ok = File.close(file)
 246     System.cmd("mix", ["format", config_path])
 247
 248     shell_info(
 249       "Database configuration settings have been exported to config/#{env}.exported_from_db.secret.exs"
 250     )
 251   end
 252
 253   if Code.ensure_loaded?(Config.Reader) do
 254     defp config_header, do: "import Config\r\n\r\n"
 255     defp read_file(config_file), do: Config.Reader.read_imports!(config_file)
 256   else
 257     defp config_header, do: "use Mix.Config\r\n\r\n"
 258     defp read_file(config_file), do: Mix.Config.eval!(config_file)
 259   end
 260
 261   defp write_and_delete(config, file, delete?) do
 262     config
 263     |> write(file)
 264     |> delete(delete?)
 265   end
 266
 267   defp write(config, file) do
 268     value = inspect(config.value, limit: :infinity)
 269
 270     IO.write(file, "config #{inspect(config.group)}, #{inspect(config.key)}, #{value}\r\n\r\n")
 271
 272     config
 273   end
 274
 275   defp delete(config, true) do
 276     {:ok, _} = Repo.delete(config)
 277
 278     shell_info(
 279       "config #{inspect(config.group)}, #{inspect(config.key)} was deleted from the ConfigDB."
 280     )
 281   end
 282
 283   defp delete(_config, _), do: :ok
 284
 285   defp dump(%Pleroma.ConfigDB{} = config) do
 286     value = inspect(config.value, limit: :infinity)
 287
 288     shell_info("config #{inspect(config.group)}, #{inspect(config.key)}, #{value}\r\n\r\n")
 289   end
 290
 291   defp dump_group(group) when is_atom(group) do
 292     group
 293     |> ConfigDB.get_all_by_group()
 294     |> Enum.each(&dump/1)
 295   end
 296
 297   defp group_exists?(group) do
 298     group
 299     |> ConfigDB.get_all_by_group()
 300     |> Enum.empty?()
 301   end
 302
 303   defp maybe_atomize(arg) when is_atom(arg), do: arg
 304
 305   defp maybe_atomize(arg) when is_binary(arg) do
 306     if Pleroma.ConfigDB.module_name?(arg) do
 307       String.to_existing_atom("Elixir." <> arg)
 308     else
 309       String.to_atom(arg)
 310     end
 311   end
 312
 313   defp check_configdb(callback) do
 314     with true <- Pleroma.Config.get([:configurable_from_database]) do
 315       callback.()
 316     else
 317       _ ->
 318         shell_error(
 319           "ConfigDB not enabled. Please check the value of :configurable_from_database in your configuration."
 320         )
 321     end
 322   end
 323
 324   defp delete_key(group, key) do
 325     check_configdb(fn ->
 326       group
 327       |> ConfigDB.get_all_by_group_and_key(key)
 328       |> Enum.each(&delete(&1, true))
 329     end)
 330   end
 331
 332   defp delete_group(group) do
 333     check_configdb(fn ->
 334       with true <- group_exists?(group) do
 335         shell_info("The following settings will be removed from ConfigDB:\n")
 336         dump_group(group)
 337
 338         group
 339         |> ConfigDB.get_all_by_group()
 340         |> Enum.each(&delete(&1, true))
 341       else
 342         _ -> shell_error("No settings in ConfigDB for #{inspect(group)}. Aborting.")
 343       end
 344     end)
 345   end
 346
 347   defp truncatedb do
 348     Ecto.Adapters.SQL.query!(Repo, "TRUNCATE config;")
 349     Ecto.Adapters.SQL.query!(Repo, "ALTER SEQUENCE config_id_seq RESTART;")
 350   end
 351 end