merging release default config on app start

lib/mix/tasks/pleroma/docs.ex

@@ -28,7 +28,7 @@ def run(_) do
   defp do_run(implementation) do
     start_pleroma()
 
-    with descriptions <- Pleroma.Config.Loader.load("config/description.exs"),
+    with descriptions <- Pleroma.Config.Loader.read("config/description.exs"),
          {:ok, file_path} <-
            Pleroma.Docs.Generator.process(
              implementation,

lib/pleroma/application.ex

@@ -31,6 +31,7 @@ def user_agent do
   # See http://elixir-lang.org/docs/stable/elixir/Application.html
   # for more information on OTP Applications
   def start(_type, _args) do
+    Pleroma.Config.Holder.to_ets()
     Pleroma.HTML.compile_scrubbers()
     Pleroma.Config.DeprecationWarnings.warn()
     Pleroma.Plugs.HTTPSecurityPlug.warn_if_disabled()

lib/pleroma/config/holder.ex

@@ -3,14 +3,38 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.Config.Holder do
-  @config Pleroma.Config.Loader.load_and_merge()
+  @config Pleroma.Config.Loader.default_config()
 
-  @spec config() :: keyword()
+  @spec to_ets() :: true
-  def config, do: @config
+  def to_ets do
+    :ets.new(:default_config, [:named_table, :protected])
 
-  @spec config(atom()) :: any()
+    default_config =
-  def config(group), do: @config[group]
+      if System.get_env("RELEASE_NAME") do
+        release_config =
+          [:code.root_dir(), "releases", System.get_env("RELEASE_VSN"), "releases.exs"]
+          |> Path.join()
+          |> Pleroma.Config.Loader.read()
 
-  @spec config(atom(), atom()) :: any()
+        Pleroma.Config.Loader.merge(@config, release_config)
-  def config(group, key), do: @config[group][key]
+      else
+        @config
+      end
+
+    :ets.insert(:default_config, {:config, default_config})
+  end
+
+  @spec default_config() :: keyword()
+  def default_config, do: from_ets()
+
+  @spec default_config(atom()) :: keyword()
+  def default_config(group), do: Keyword.get(from_ets(), group)
+
+  @spec default_config(atom(), atom()) :: keyword()
+  def default_config(group, key), do: get_in(from_ets(), [group, key])
+
+  defp from_ets do
+    [{:config, default_config}] = :ets.lookup(:default_config, :config)
+    default_config
+  end
 end

lib/pleroma/config/loader.ex

@@ -13,32 +13,22 @@ defmodule Pleroma.Config.Loader do
   ]
 
   if Code.ensure_loaded?(Config.Reader) do
-    @spec load(Path.t()) :: keyword()
+    @reader Config.Reader
-    def load(path), do: Config.Reader.read!(path)
-
-    defp do_merge(conf1, conf2), do: Config.Reader.merge(conf1, conf2)
   else
     # support for Elixir less than 1.9
-    @spec load(Path.t()) :: keyword()
+    @reader Mix.Config
-    def load(path) do
-      path
-      |> Mix.Config.eval!()
-      |> elem(0)
   end
 
-    defp do_merge(conf1, conf2), do: Mix.Config.merge(conf1, conf2)
+  @spec read(Path.t()) :: keyword()
-  end
+  def read(path), do: @reader.read!(path)
 
-  @spec load_and_merge() :: keyword()
+  @spec merge(keyword(), keyword()) :: keyword()
-  def load_and_merge do
+  def merge(c1, c2), do: @reader.merge(c1, c2)
-    all_paths =
-      if Pleroma.Config.get(:release),
-        do: ["config/config.exs", "config/releases.exs"],
-        else: ["config/config.exs"]
 
-    all_paths
+  @spec default_config() :: keyword()
-    |> Enum.map(&load(&1))
+  def default_config do
-    |> Enum.reduce([], &do_merge(&2, &1))
+    "config/config.exs"
+    |> read()
     |> filter()
   end
 

lib/pleroma/config/transfer_task.ex

@@ -83,7 +83,7 @@ defp merge_and_update(setting) do
       key = ConfigDB.from_string(setting.key)
       group = ConfigDB.from_string(setting.group)
 
-      default = Pleroma.Config.Holder.config(group, key)
+      default = Pleroma.Config.Holder.default_config(group, key)
       value = ConfigDB.from_binary(setting.value)
 
       merged_value =

lib/pleroma/docs/json.ex

@@ -15,7 +15,7 @@ def process(descriptions) do
   end
 
   def compile do
-    with config <- Pleroma.Config.Loader.load("config/description.exs") do
+    with config <- Pleroma.Config.Loader.read("config/description.exs") do
       config[:pleroma][:config_description]
       |> Pleroma.Docs.Generator.convert_to_strings()
       |> Jason.encode!()

lib/pleroma/web/admin_api/admin_api_controller.ex

@@ -834,7 +834,7 @@ def config_show(conn, _params) do
       configs = ConfigDB.get_all_as_keyword()
 
       merged =
-        Config.Holder.config()
+        Config.Holder.default_config()
         |> ConfigDB.merge(configs)
         |> Enum.map(fn {group, values} ->
           Enum.map(values, fn {key, value} ->

test/config/holder_test.exs

@@ -7,8 +7,8 @@ defmodule Pleroma.Config.HolderTest do
 
   alias Pleroma.Config.Holder
 
-  test "config/0" do
+  test "default_config/0" do
-    config = Holder.config()
+    config = Holder.default_config()
     assert config[:pleroma][Pleroma.Uploaders.Local][:uploads] == "test/uploads"
     assert config[:tesla][:adapter] == Tesla.Mock
 
@@ -20,15 +20,15 @@ test "config/0" do
     refute config[:phoenix][:serve_endpoints]
   end
 
-  test "config/1" do
+  test "default_config/1" do
-    pleroma_config = Holder.config(:pleroma)
+    pleroma_config = Holder.default_config(:pleroma)
     assert pleroma_config[Pleroma.Uploaders.Local][:uploads] == "test/uploads"
-    tesla_config = Holder.config(:tesla)
+    tesla_config = Holder.default_config(:tesla)
     assert tesla_config[:adapter] == Tesla.Mock
   end
 
-  test "config/2" do
+  test "default_config/2" do
-    assert Holder.config(:pleroma, Pleroma.Uploaders.Local) == [uploads: "test/uploads"]
+    assert Holder.default_config(:pleroma, Pleroma.Uploaders.Local) == [uploads: "test/uploads"]
-    assert Holder.config(:tesla, :adapter) == Tesla.Mock
+    assert Holder.default_config(:tesla, :adapter) == Tesla.Mock
   end
 end

test/config/loader_test.exs

@@ -7,28 +7,13 @@ defmodule Pleroma.Config.LoaderTest do
 
   alias Pleroma.Config.Loader
 
-  test "load/1" do
+  test "read/1" do
-    config = Loader.load("test/fixtures/config/temp.secret.exs")
+    config = Loader.read("test/fixtures/config/temp.secret.exs")
     assert config[:pleroma][:first_setting][:key] == "value"
     assert config[:pleroma][:first_setting][:key2] == [Pleroma.Repo]
     assert config[:quack][:level] == :info
   end
 
-  test "load_and_merge/0" do
-    config = Loader.load_and_merge()
-
-    refute config[:pleroma][Pleroma.Repo]
-    refute config[:pleroma][Pleroma.Web.Endpoint]
-    refute config[:pleroma][:env]
-    refute config[:pleroma][:configurable_from_database]
-    refute config[:pleroma][:database]
-    refute config[:phoenix][:serve_endpoints]
-
-    assert config[:pleroma][:ecto_repos] == [Pleroma.Repo]
-    assert config[:pleroma][Pleroma.Uploaders.Local][:uploads] == "test/uploads"
-    assert config[:tesla][:adapter] == Tesla.Mock
-  end
-
   test "filter_group/2" do
     assert Loader.filter_group(:pleroma,
              pleroma: [

test/config/transfer_task_test.exs

@@ -70,7 +70,7 @@ test "transfer config values for 1 group and some keys" do
 
     assert Application.get_env(:quack, :level) == :info
     assert Application.get_env(:quack, :meta) == [:none]
-    default = Pleroma.Config.Holder.config(:quack, :webhook_url)
+    default = Pleroma.Config.Holder.default_config(:quack, :webhook_url)
     assert Application.get_env(:quack, :webhook_url) == default
 
     on_exit(fn ->