X-Git-Url: http://git.squeep.com/?a=blobdiff_plain;f=lib%2Fpleroma%2Fconfig%2Fconfig_db.ex;h=4097ee5b75cbe7ea6a58a7f00a1e36714f47d952;hb=d9f8941dac983d89709645831b41e02adc454740;hp=e433ce442ebce8f88721c7678d88a1bbde6dd70b;hpb=29155137fdae15fccfaa68fb9c954e98078ce0c4;p=akkoma

diff --git a/lib/pleroma/config/config_db.ex b/lib/pleroma/config/config_db.ex
index e433ce442..4097ee5b7 100644
--- a/lib/pleroma/config/config_db.ex
+++ b/lib/pleroma/config/config_db.ex
@@ -1,24 +1,64 @@
 # 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 Pleroma.ConfigDB do
   use Ecto.Schema
+
   import Ecto.Changeset
+  import Ecto.Query
   import Pleroma.Web.Gettext
+
   alias __MODULE__
   alias Pleroma.Repo
 
   @type t :: %__MODULE__{}
 
+  @full_key_update [
+    {:pleroma, :ecto_repos},
+    {:quack, :meta},
+    {:mime, :types},
+    {:cors_plug, [:max_age, :methods, :expose, :headers]},
+    {:auto_linker, :opts},
+    {:swarm, :node_blacklist},
+    {:logger, :backends}
+  ]
+
+  @full_subkey_update [
+    {:pleroma, :assets, :mascots},
+    {:pleroma, :emoji, :groups},
+    {:pleroma, :workers, :retries},
+    {:pleroma, :mrf_subchain, :match_actor},
+    {:pleroma, :mrf_keyword, :replace}
+  ]
+
+  @regex ~r/^~r(?'delimiter'[\/|"'([{<]{1})(?'pattern'.+)[\/|"')\]}>]{1}(?'modifier'[uismxfU]*)/u
+
+  @delimiters ["/", "|", "\"", "'", {"(", ")"}, {"[", "]"}, {"{", "}"}, {"<", ">"}]
+
   schema "config" do
     field(:key, :string)
     field(:group, :string)
     field(:value, :binary)
+    field(:db, {:array, :string}, virtual: true, default: [])
 
     timestamps()
   end
 
+  @spec get_all_as_keyword() :: keyword()
+  def get_all_as_keyword do
+    ConfigDB
+    |> select([c], {c.group, c.key, c.value})
+    |> Repo.all()
+    |> Enum.reduce([], fn {group, key, value}, acc ->
+      group = ConfigDB.from_string(group)
+      key = ConfigDB.from_string(key)
+      value = from_binary(value)
+
+      Keyword.update(acc, group, [{key, value}], &Keyword.merge(&1, [{key, value}]))
+    end)
+  end
+
   @spec get_by_params(map()) :: ConfigDB.t() | nil
   def get_by_params(params), do: Repo.get_by(ConfigDB, params)
 
@@ -46,31 +86,76 @@ defmodule Pleroma.ConfigDB do
     |> Repo.update()
   end
 
-  @full_key_update [
-    {:pleroma, :ecto_repos},
-    {:pleroma, :assets},
-    {:quack, :meta},
-    {:mime, :types},
-    {:cors_plug, [:max_age, :methods, :expose, :headers]},
-    {:auto_linker, :opts},
-    {:swarm, :node_blacklist},
-    {:logger, :backends}
-  ]
+  @spec get_db_keys(ConfigDB.t()) :: [String.t()]
+  def get_db_keys(%ConfigDB{} = config) do
+    config.value
+    |> ConfigDB.from_binary()
+    |> get_db_keys(config.key)
+  end
 
-  defp only_full_update?(%ConfigDB{} = config) do
-    config_group = ConfigDB.from_string(config.group)
-    config_key = ConfigDB.from_string(config.key)
+  @spec get_db_keys(keyword(), any()) :: [String.t()]
+  def get_db_keys(value, key) do
+    if Keyword.keyword?(value) do
+      value |> Keyword.keys() |> Enum.map(&convert(&1))
+    else
+      [convert(key)]
+    end
+  end
 
-    Enum.any?(@full_key_update, fn
-      {group, key} when is_list(key) ->
-        config_group == group and config_key in key
+  @spec merge_group(atom(), atom(), keyword(), keyword()) :: keyword()
+  def merge_group(group, key, old_value, new_value) do
+    new_keys = to_map_set(new_value)
 
-      {group, key} ->
-        config_group == group and config_key == key
+    intersect_keys =
+      old_value |> to_map_set() |> MapSet.intersection(new_keys) |> MapSet.to_list()
+
+    merged_value = ConfigDB.merge(old_value, new_value)
+
+    @full_subkey_update
+    |> Enum.map(fn
+      {g, k, subkey} when g == group and k == key ->
+        if subkey in intersect_keys, do: subkey, else: []
+
+      _ ->
+        []
+    end)
+    |> List.flatten()
+    |> Enum.reduce(merged_value, fn subkey, acc ->
+      Keyword.put(acc, subkey, new_value[subkey])
     end)
   end
 
-  defp can_be_partially_updated?(%ConfigDB{} = config), do: not only_full_update?(config)
+  defp to_map_set(keyword) do
+    keyword
+    |> Keyword.keys()
+    |> MapSet.new()
+  end
+
+  @spec sub_key_full_update?(atom(), atom(), [Keyword.key()]) :: boolean()
+  def sub_key_full_update?(group, key, subkeys) do
+    Enum.any?(@full_subkey_update, fn {g, k, subkey} ->
+      g == group and k == key and subkey in subkeys
+    end)
+  end
+
+  @spec merge(keyword(), keyword()) :: keyword()
+  def merge(config1, config2) when is_list(config1) and is_list(config2) do
+    Keyword.merge(config1, config2, fn _, app1, app2 ->
+      if Keyword.keyword?(app1) and Keyword.keyword?(app2) do
+        Keyword.merge(app1, app2, &deep_merge/3)
+      else
+        app2
+      end
+    end)
+  end
+
+  defp deep_merge(_key, value1, value2) do
+    if Keyword.keyword?(value1) and Keyword.keyword?(value2) do
+      Keyword.merge(value1, value2, &deep_merge/3)
+    else
+      value2
+    end
+  end
 
   @spec update_or_create(map()) :: {:ok, ConfigDB.t()} | {:error, Changeset.t()}
   def update_or_create(params) do
@@ -82,8 +167,14 @@ defmodule Pleroma.ConfigDB do
          old_value <- from_binary(config.value),
          transformed_value <- do_transform(params[:value]),
          {:can_be_merged, true, config} <- {:can_be_merged, is_list(transformed_value), config},
-         new_value <- DeepMerge.deep_merge(old_value, transformed_value) do
-      ConfigDB.update(config, %{value: new_value, transformed?: true})
+         new_value <-
+           merge_group(
+             ConfigDB.from_string(config.group),
+             ConfigDB.from_string(config.key),
+             old_value,
+             transformed_value
+           ) do
+      ConfigDB.update(config, %{value: new_value})
     else
       {reason, false, config} when reason in [:partial_update, :can_be_merged] ->
         ConfigDB.update(config, params)
@@ -93,7 +184,22 @@ defmodule Pleroma.ConfigDB do
     end
   end
 
-  @spec delete(map()) :: {:ok, ConfigDB.t()} | {:error, Changeset.t()} | {:ok, nil}
+  defp can_be_partially_updated?(%ConfigDB{} = config), do: not only_full_update?(config)
+
+  defp only_full_update?(%ConfigDB{} = config) do
+    config_group = ConfigDB.from_string(config.group)
+    config_key = ConfigDB.from_string(config.key)
+
+    Enum.any?(@full_key_update, fn
+      {group, key} when is_list(key) ->
+        config_group == group and config_key in key
+
+      {group, key} ->
+        config_group == group and config_key == key
+    end)
+  end
+
+  @spec delete(map()) :: {:ok, ConfigDB.t()} | {:error, Changeset.t()}
   def delete(params) do
     search_opts = Map.delete(params, :subkeys)
 
@@ -101,12 +207,15 @@ defmodule Pleroma.ConfigDB do
          {config, sub_keys} when is_list(sub_keys) <- {config, params[:subkeys]},
          old_value <- from_binary(config.value),
          keys <- Enum.map(sub_keys, &do_transform_string(&1)),
-         new_value <- Keyword.drop(old_value, keys) do
+         {:partial_remove, config, new_value} when new_value != [] <-
+           {:partial_remove, config, Keyword.drop(old_value, keys)} do
       ConfigDB.update(config, %{value: new_value})
     else
+      {:partial_remove, config, []} ->
+        Repo.delete(config)
+
       {config, nil} ->
         Repo.delete(config)
-        {:ok, nil}
 
       nil ->
         err =
@@ -127,15 +236,10 @@ defmodule Pleroma.ConfigDB do
   end
 
   @spec from_string(String.t()) :: atom() | no_return()
-  def from_string(":" <> entity), do: String.to_existing_atom(entity)
+  def from_string(string), do: do_transform_string(string)
 
-  def from_string(entity) when is_binary(entity) do
-    if is_module_name?(entity) do
-      String.to_existing_atom("Elixir.#{entity}")
-    else
-      entity
-    end
-  end
+  @spec convert(any()) :: any()
+  def convert(entity), do: do_convert(entity)
 
   defp do_convert(entity) when is_list(entity) do
     for v <- entity, into: [], do: do_convert(v)
@@ -174,19 +278,22 @@ defmodule Pleroma.ConfigDB do
     }
   end
 
-  defp do_convert({:dispatch, [entity]}), do: %{"tuple" => [":dispatch", [inspect(entity)]]}
-  # TODO: will become useless after removing hackney
-  defp do_convert({:partial_chain, entity}), do: %{"tuple" => [":partial_chain", inspect(entity)]}
+  defp do_convert(entity) when is_tuple(entity) do
+    value =
+      entity
+      |> Tuple.to_list()
+      |> do_convert()
 
-  defp do_convert(entity) when is_tuple(entity),
-    do: %{"tuple" => do_convert(Tuple.to_list(entity))}
+    %{"tuple" => value}
+  end
 
-  defp do_convert(entity) when is_boolean(entity) or is_number(entity) or is_nil(entity),
-    do: entity
+  defp do_convert(entity) when is_boolean(entity) or is_number(entity) or is_nil(entity) do
+    entity
+  end
 
   defp do_convert(entity)
        when is_atom(entity) and entity in [:"tlsv1.1", :"tlsv1.2", :"tlsv1.3"] do
-    ":#{to_string(entity)}"
+    ":#{entity}"
   end
 
   defp do_convert(entity) when is_atom(entity), do: inspect(entity)
@@ -202,6 +309,9 @@ defmodule Pleroma.ConfigDB do
 
   def transform(entity), do: to_binary(entity)
 
+  @spec transform_with_out_binary(any()) :: any()
+  def transform_with_out_binary(entity), do: do_transform(entity)
+
   @spec to_binary(any()) :: binary()
   def to_binary(entity), do: :erlang.term_to_binary(entity)
 
@@ -211,17 +321,6 @@ defmodule Pleroma.ConfigDB do
     {:proxy_url, {do_transform_string(type), parse_host(host), port}}
   end
 
-  defp do_transform(%{"tuple" => [":dispatch", [entity]]}) do
-    {dispatch_settings, []} = do_eval(entity)
-    {:dispatch, [dispatch_settings]}
-  end
-
-  # TODO: will become useless after removing hackney
-  defp do_transform(%{"tuple" => [":partial_chain", entity]}) do
-    {partial_chain, []} = do_eval(entity)
-    {:partial_chain, partial_chain}
-  end
-
   defp do_transform(%{"tuple" => entity}) do
     Enum.reduce(entity, {}, fn val, acc -> Tuple.append(acc, do_transform(val)) end)
   end
@@ -256,10 +355,9 @@ defmodule Pleroma.ConfigDB do
     end
   end
 
-  @delimiters ["/", "|", "\"", "'", {"(", ")"}, {"[", "]"}, {"{", "}"}, {"<", ">"}]
-
-  defp find_valid_delimiter([], _string, _),
-    do: raise(ArgumentError, message: "valid delimiter for Regex expression not found")
+  defp find_valid_delimiter([], _string, _) do
+    raise(ArgumentError, message: "valid delimiter for Regex expression not found")
+  end
 
   defp find_valid_delimiter([{leading, closing} = delimiter | others], pattern, regex_delimiter)
        when is_tuple(delimiter) do
@@ -278,11 +376,9 @@ defmodule Pleroma.ConfigDB do
     end
   end
 
-  @regex_parts ~r/^~r(?'delimiter'[\/|"'([{<]{1})(?'pattern'.+)[\/|"')\]}>]{1}(?'modifier'[uismxfU]*)/u
-
   defp do_transform_string("~r" <> _pattern = regex) do
     with %{"modifier" => modifier, "pattern" => pattern, "delimiter" => regex_delimiter} <-
-           Regex.named_captures(@regex_parts, regex),
+           Regex.named_captures(@regex, regex),
          {:ok, {leading, closing}} <- find_valid_delimiter(@delimiters, pattern, regex_delimiter),
          {result, _} <- Code.eval_string("~r#{leading}#{pattern}#{closing}#{modifier}") do
       result
@@ -301,12 +397,7 @@ defmodule Pleroma.ConfigDB do
 
   @spec is_module_name?(String.t()) :: boolean()
   def is_module_name?(string) do
-    Regex.match?(~r/^(Pleroma|Phoenix|Tesla|Quack)\./, string) or
+    Regex.match?(~r/^(Pleroma|Phoenix|Tesla|Quack|Ueberauth|Swoosh)\./, string) or
       string in ["Oban", "Ueberauth", "ExSyslogger"]
   end
-
-  defp do_eval(entity) do
-    cleaned_string = String.replace(entity, ~r/[^\w|^{:,[|^,|^[|^\]^}|^\/|^\.|^"]^\s/, "")
-    Code.eval_string(cleaned_string)
-  end
 end