X-Git-Url: https://git.squeep.com/?a=blobdiff_plain;f=lib%2Fmix%2Ftasks%2Fpleroma%2Fconfig.ex;h=2ecad3578071c53e41e0f954e0bdf8fa4bf4607a;hb=d817bae802c40bd2db9a88970cf24e98374b0af0;hp=bb126463c790b0a88967c222daa07bcd70a2c0b6;hpb=2753285b7722fdb47f0ebb2180e997cf72f65d1a;p=akkoma

diff --git a/lib/mix/tasks/pleroma/config.ex b/lib/mix/tasks/pleroma/config.ex
index bb126463c..2ecad3578 100644
--- a/lib/mix/tasks/pleroma/config.ex
+++ b/lib/mix/tasks/pleroma/config.ex
@@ -1,101 +1,359 @@
 # Pleroma: A lightweight social networking server
-# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Mix.Tasks.Pleroma.Config do
   use Mix.Task
+
+  import Ecto.Query
   import Mix.Pleroma
+
+  alias Pleroma.ConfigDB
   alias Pleroma.Repo
-  alias Pleroma.Web.AdminAPI.Config
+
   @shortdoc "Manages the location of the config"
   @moduledoc File.read!("docs/administration/CLI_tasks/config.md")
 
-  @groups [
-    :pleroma,
-    :logger,
-    :quack,
-    :mime,
-    :tesla,
-    :phoenix,
-    :cors_plug,
-    :auto_linker,
-    :esshd,
-    :ueberauth,
-    :prometheus,
-    :http_signatures,
-    :web_push_encryption,
-    :joken
-  ]
-
   def run(["migrate_to_db"]) do
+    check_configdb(fn ->
+      start_pleroma()
+      migrate_to_db()
+    end)
+  end
+
+  def run(["migrate_from_db" | options]) do
+    check_configdb(fn ->
+      start_pleroma()
+
+      {opts, _} =
+        OptionParser.parse!(options,
+          strict: [env: :string, delete: :boolean],
+          aliases: [d: :delete]
+        )
+
+      migrate_from_db(opts)
+    end)
+  end
+
+  def run(["dump"]) do
+    check_configdb(fn ->
+      start_pleroma()
+
+      header = config_header()
+
+      settings =
+        ConfigDB
+        |> Repo.all()
+        |> Enum.sort()
+
+      unless settings == [] do
+        shell_info("#{header}")
+
+        Enum.each(settings, &dump(&1))
+      else
+        shell_error("No settings in ConfigDB.")
+      end
+    end)
+  end
+
+  def run(["dump", group, key]) do
+    check_configdb(fn ->
+      start_pleroma()
+
+      group = maybe_atomize(group)
+      key = maybe_atomize(key)
+
+      group
+      |> ConfigDB.get_by_group_and_key(key)
+      |> dump()
+    end)
+  end
+
+  def run(["dump", group]) do
+    check_configdb(fn ->
+      start_pleroma()
+
+      group = maybe_atomize(group)
+
+      dump_group(group)
+    end)
+  end
+
+  def run(["groups"]) do
+    check_configdb(fn ->
+      start_pleroma()
+
+      groups =
+        ConfigDB
+        |> distinct([c], true)
+        |> select([c], c.group)
+        |> Repo.all()
+
+      if length(groups) > 0 do
+        shell_info("The following configuration groups are set in ConfigDB:\r\n")
+        groups |> Enum.each(fn x -> shell_info("-  #{x}") end)
+        shell_info("\r\n")
+      end
+    end)
+  end
+
+  def run(["reset", "--force"]) do
+    check_configdb(fn ->
+      start_pleroma()
+      truncatedb()
+      shell_info("The ConfigDB settings have been removed from the database.")
+    end)
+  end
+
+  def run(["reset"]) do
+    check_configdb(fn ->
+      start_pleroma()
+
+      shell_info("The following settings will be permanently removed:")
+
+      ConfigDB
+      |> Repo.all()
+      |> Enum.sort()
+      |> Enum.each(&dump(&1))
+
+      shell_error("\nTHIS CANNOT BE UNDONE!")
+
+      if shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
+        truncatedb()
+
+        shell_info("The ConfigDB settings have been removed from the database.")
+      else
+        shell_error("No changes made.")
+      end
+    end)
+  end
+
+  def run(["delete", "--force", group, key]) do
+    start_pleroma()
+
+    group = maybe_atomize(group)
+    key = maybe_atomize(key)
+
+    delete_key(group, key)
+  end
+
+  def run(["delete", "--force", group]) do
     start_pleroma()
 
-    if Pleroma.Config.get([:instance, :dynamic_configuration]) do
-      Enum.each(@groups, &load_and_create(&1))
+    group = maybe_atomize(group)
+
+    with true <- group_exists?(group) do
+      shell_info("The following settings will be removed from ConfigDB:\n")
+      dump_group(group)
+      delete_group(group)
     else
-      Mix.shell().info(
-        "Migration is not allowed by config. You can change this behavior in instance settings."
-      )
+      _ -> shell_error("No settings in ConfigDB for #{inspect(group)}. Aborting.")
     end
   end
 
-  def run(["migrate_from_db" | options]) do
+  def run(["delete", group, key]) do
     start_pleroma()
 
-    {opts, _} =
-      OptionParser.parse!(options,
-        strict: [env: :string, delete_from_db: :boolean],
-        aliases: [d: :delete_from_db]
-      )
+    group = maybe_atomize(group)
+    key = maybe_atomize(key)
 
-    with {:active?, true} <- {:active?, Pleroma.Config.get([:instance, :dynamic_configuration])},
-         env_path when is_binary(env_path) <- opts[:env],
-         config_path <- "config/#{env_path}.exported_from_db.secret.exs",
-         {:ok, file} <- File.open(config_path, [:write, :utf8]) do
-      IO.write(file, "use Mix.Config\r\n")
+    if shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
+      delete_key(group, key)
+    else
+      shell_error("No changes made.")
+    end
+  end
 
-      Config
-      |> Repo.all()
-      |> Enum.each(&write_to_file_with_deletion(&1, file, opts[:delete_from_db]))
+  def run(["delete", group]) do
+    start_pleroma()
+
+    group = maybe_atomize(group)
 
-      File.close(file)
-      System.cmd("mix", ["format", config_path])
+    with true <- group_exists?(group) do
+      shell_info("The following settings will be removed from ConfigDB:\n")
+      dump_group(group)
+
+      if shell_prompt("Are you sure you want to continue?", "n") in ~w(Yn Y y) do
+        delete_group(group)
+      else
+        shell_error("No changes made.")
+      end
     else
-      {:active?, false} ->
-        Mix.shell().info(
-          "migration is not allowed by config. You can change this behavior in instance settings."
-        )
+      _ -> shell_error("No settings in ConfigDB for #{inspect(group)}. Aborting.")
+    end
+  end
 
-      error ->
-        Mix.shell().info("error occuried while opening file. #{inspect(error)}")
+  @spec migrate_to_db(Path.t() | nil) :: any()
+  def migrate_to_db(file_path \\ nil) do
+    with :ok <- Pleroma.Config.DeprecationWarnings.warn() do
+      config_file =
+        if file_path do
+          file_path
+        else
+          if Pleroma.Config.get(:release) do
+            Pleroma.Config.get(:config_path)
+          else
+            "config/#{Pleroma.Config.get(:env)}.secret.exs"
+          end
+        end
+
+      do_migrate_to_db(config_file)
+    else
+      _ ->
+        shell_error("Migration is not allowed until all deprecation warnings have been resolved.")
     end
   end
 
-  defp load_and_create(group) do
+  defp do_migrate_to_db(config_file) do
+    if File.exists?(config_file) do
+      shell_info("Migrating settings from file: #{Path.expand(config_file)}")
+      truncatedb()
+
+      custom_config =
+        config_file
+        |> read_file()
+        |> elem(0)
+
+      custom_config
+      |> Keyword.keys()
+      |> Enum.each(&create(&1, custom_config))
+    else
+      shell_info("To migrate settings, you must define custom settings in #{config_file}.")
+    end
+  end
+
+  defp create(group, settings) do
     group
-    |> Application.get_all_env()
-    |> Enum.reject(fn {k, _v} -> k in [Pleroma.Repo, :env] end)
+    |> Pleroma.Config.Loader.filter_group(settings)
     |> Enum.each(fn {key, value} ->
-      key_str = inspect(key)
+      {:ok, _} = ConfigDB.update_or_create(%{group: group, key: key, value: value})
 
-      {:ok, _} = Config.update_or_create(%{group: ":#{group}", key: key_str, value: value})
-      Mix.shell().info("settings for key #{key_str} migrated.")
+      shell_info("Settings for key #{key} migrated.")
     end)
 
-    Mix.shell().info("settings for group :#{group} migrated.")
+    shell_info("Settings for group #{inspect(group)} migrated.")
   end
 
-  defp write_to_file_with_deletion(config, file, with_deletion) do
-    IO.write(
-      file,
-      "config #{config.group}, #{config.key}, #{
-        inspect(Config.from_binary(config.value), limit: :infinity)
-      }\r\n\r\n"
+  defp migrate_from_db(opts) do
+    env = opts[:env] || Pleroma.Config.get(:env)
+
+    config_path =
+      if Pleroma.Config.get(:release) do
+        :config_path
+        |> Pleroma.Config.get()
+        |> Path.dirname()
+      else
+        "config"
+      end
+      |> Path.join("#{env}.exported_from_db.secret.exs")
+
+    file = File.open!(config_path, [:write, :utf8])
+
+    IO.write(file, config_header())
+
+    ConfigDB
+    |> Repo.all()
+    |> Enum.each(&write_and_delete(&1, file, opts[:delete]))
+
+    :ok = File.close(file)
+    System.cmd("mix", ["format", config_path])
+
+    shell_info(
+      "Database configuration settings have been exported to config/#{env}.exported_from_db.secret.exs"
     )
+  end
+
+  if Code.ensure_loaded?(Config.Reader) do
+    defp config_header, do: "import Config\r\n\r\n"
+    defp read_file(config_file), do: Config.Reader.read_imports!(config_file)
+  else
+    defp config_header, do: "use Mix.Config\r\n\r\n"
+    defp read_file(config_file), do: Mix.Config.eval!(config_file)
+  end
+
+  defp write_and_delete(config, file, delete?) do
+    config
+    |> write(file)
+    |> delete(delete?)
+  end
+
+  defp write(config, file) do
+    value = inspect(config.value, limit: :infinity)
+
+    IO.write(file, "config #{inspect(config.group)}, #{inspect(config.key)}, #{value}\r\n\r\n")
+
+    config
+  end
+
+  defp delete(config, true) do
+    {:ok, _} = Repo.delete(config)
 
-    if with_deletion do
-      {:ok, _} = Repo.delete(config)
-      Mix.shell().info("#{config.key} deleted from DB.")
+    shell_info(
+      "config #{inspect(config.group)}, #{inspect(config.key)} was deleted from the ConfigDB."
+    )
+  end
+
+  defp delete(_config, _), do: :ok
+
+  defp dump(%ConfigDB{} = config) do
+    value = inspect(config.value, limit: :infinity)
+
+    shell_info("config #{inspect(config.group)}, #{inspect(config.key)}, #{value}\r\n\r\n")
+  end
+
+  defp dump(_), do: :noop
+
+  defp dump_group(group) when is_atom(group) do
+    group
+    |> ConfigDB.get_all_by_group()
+    |> Enum.each(&dump/1)
+  end
+
+  defp group_exists?(group) do
+    group
+    |> ConfigDB.get_all_by_group()
+    |> Enum.any?()
+  end
+
+  defp maybe_atomize(arg) when is_atom(arg), do: arg
+ 
+   defp maybe_atomize(":" <> arg), do: maybe_atomize(arg)
+
+  defp maybe_atomize(arg) when is_binary(arg) do
+    if ConfigDB.module_name?(arg) do
+      String.to_existing_atom("Elixir." <> arg)
+    else
+      String.to_atom(arg)
     end
   end
+
+  defp check_configdb(callback) do
+    with true <- Pleroma.Config.get([:configurable_from_database]) do
+      callback.()
+    else
+      _ ->
+        shell_error(
+          "ConfigDB not enabled. Please check the value of :configurable_from_database in your configuration."
+        )
+    end
+  end
+
+  defp delete_key(group, key) do
+    check_configdb(fn ->
+      ConfigDB.delete(%{group: group, key: key})
+    end)
+  end
+
+  defp delete_group(group) do
+    check_configdb(fn ->
+      group
+      |> ConfigDB.get_all_by_group()
+      |> Enum.each(&ConfigDB.delete/1)
+    end)
+  end
+
+  defp truncatedb do
+    Ecto.Adapters.SQL.query!(Repo, "TRUNCATE config;")
+    Ecto.Adapters.SQL.query!(Repo, "ALTER SEQUENCE config_id_seq RESTART;")
+  end
 end