No OneTemporary
Actions

Size

22 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/config/loader.ex b/lib/pleroma/config/loader.ex
	index 6ca6550bd..0f3ecf1ed 100644
	--- a/lib/pleroma/config/loader.ex
	+++ b/lib/pleroma/config/loader.ex
	@@ -1,53 +1,53 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.Loader do
	@reject_keys [
	Pleroma.Repo,
	Pleroma.Web.Endpoint,
	:env,
	:configurable_from_database,
	:database,
	:swarm
	]

	if Code.ensure_loaded?(Config.Reader) do
	@reader Config.Reader

	def read(path), do: @reader.read!(path)
	else
	# support for Elixir less than 1.9
	@reader Mix.Config
	def read(path) do
	path
	\|> @reader.eval!()
	\|> elem(0)
	end
	end

	@spec read(Path.t()) :: keyword()

	@spec merge(keyword(), keyword()) :: keyword()
	def merge(c1, c2), do: @reader.merge(c1, c2)

	@spec default_config() :: keyword()
	def default_config do
	"config/config.exs"
	\|> read()
	\|> filter()
	end

	defp filter(configs) do
	configs
	\|> Keyword.keys()
	\|> Enum.reduce([], &Keyword.put(&2, &1, filter_group(&1, configs)))
	end

	@spec filter_group(atom(), keyword()) :: keyword()
	def filter_group(group, configs) do
	Enum.reject(configs[group], fn {key, _v} ->
	- key in @reject_keys or (group == :phoenix and key == :serve_endpoints)
	+ key in @reject_keys or (group == :phoenix and key == :serve_endpoints) or group == :postgrex
	end)
	end
	end
	diff --git a/lib/pleroma/config/transfer_task.ex b/lib/pleroma/config/transfer_task.ex
	index f4722f99d..c02b70e96 100644
	--- a/lib/pleroma/config/transfer_task.ex
	+++ b/lib/pleroma/config/transfer_task.ex
	@@ -1,207 +1,209 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.TransferTask do
	use Task

	alias Pleroma.Config
	alias Pleroma.ConfigDB
	alias Pleroma.Repo

	require Logger

	@type env() :: :test \| :benchmark \| :dev \| :prod

	@reboot_time_keys [
	{:pleroma, :hackney_pools},
	{:pleroma, :chat},
	{:pleroma, Oban},
	{:pleroma, :rate_limit},
	{:pleroma, :markup},
	{:pleroma, :streamer},
	{:pleroma, :pools},
	{:pleroma, :connections_pool}
	]

	@reboot_time_subkeys [
	{:pleroma, Pleroma.Captcha, [:seconds_valid]},
	{:pleroma, Pleroma.Upload, [:proxy_remote]},
	{:pleroma, :instance, [:upload_limit]},
	{:pleroma, :email_notifications, [:digest]},
	{:pleroma, :oauth2, [:clean_expired_tokens]},
	{:pleroma, Pleroma.ActivityExpiration, [:enabled]},
	{:pleroma, Pleroma.ScheduledActivity, [:enabled]},
	{:pleroma, :gopher, [:enabled]}
	]

	def start_link(_) do
	load_and_update_env()
	if Config.get(:env) == :test, do: Ecto.Adapters.SQL.Sandbox.checkin(Repo)
	:ignore
	end

	@spec load_and_update_env([ConfigDB.t()], boolean()) :: :ok
	def load_and_update_env(deleted_settings \\ [], restart_pleroma? \\ true) do
	with {_, true} <- {:configurable, Config.get(:configurable_from_database)} do
	# We need to restart applications for loaded settings take effect

	- # TODO: some problem with prometheus after restart!
	- reject_restart =
	- if restart_pleroma? do
	- [nil, :prometheus]
	- else
	- [:pleroma, nil, :prometheus]
	- end
	-
	{logger, other} =
	(Repo.all(ConfigDB) ++ deleted_settings)
	\|> Enum.map(&transform_and_merge/1)
	\|> Enum.split_with(fn {group, _, _, _} -> group in [:logger, :quack] end)

	logger
	\|> Enum.sort()
	\|> Enum.each(&configure/1)

	started_applications = Application.started_applications()

	+ # TODO: some problem with prometheus after restart!
	+ reject = [nil, :prometheus, :postgrex]
	+
	+ reject =
	+ if restart_pleroma? do
	+ reject
	+ else
	+ [:pleroma \| reject]
	+ end
	+
	other
	\|> Enum.map(&update/1)
	\|> Enum.uniq()
	- \|> Enum.reject(&(&1 in reject_restart))
	+ \|> Enum.reject(&(&1 in reject))
	\|> maybe_set_pleroma_last()
	\|> Enum.each(&restart(started_applications, &1, Config.get(:env)))

	:ok
	else
	{:configurable, false} -> Restarter.Pleroma.rebooted()
	end
	end

	defp maybe_set_pleroma_last(apps) do
	# to be ensured that pleroma will be restarted last
	if :pleroma in apps do
	apps
	\|> List.delete(:pleroma)
	\|> List.insert_at(-1, :pleroma)
	else
	Restarter.Pleroma.rebooted()
	apps
	end
	end

	defp transform_and_merge(%{group: group, key: key, value: value} = setting) do
	group = ConfigDB.from_string(group)
	key = ConfigDB.from_string(key)
	value = ConfigDB.from_binary(value)

	default = Config.Holder.default_config(group, key)

	merged =
	cond do
	Ecto.get_meta(setting, :state) == :deleted -> default
	can_be_merged?(default, value) -> ConfigDB.merge_group(group, key, default, value)
	true -> value
	end

	{group, key, value, merged}
	end

	# change logger configuration in runtime, without restart
	defp configure({:quack, key, _, merged}) do
	Logger.configure_backend(Quack.Logger, [{key, merged}])
	:ok = update_env(:quack, key, merged)
	end

	defp configure({_, :backends, _, merged}) do
	# removing current backends
	Enum.each(Application.get_env(:logger, :backends), &Logger.remove_backend/1)

	Enum.each(merged, &Logger.add_backend/1)

	:ok = update_env(:logger, :backends, merged)
	end

	defp configure({_, key, _, merged}) when key in [:console, :ex_syslogger] do
	merged =
	if key == :console do
	put_in(merged[:format], merged[:format] <> "\n")
	else
	merged
	end

	backend =
	if key == :ex_syslogger,
	do: {ExSyslogger, :ex_syslogger},
	else: key

	Logger.configure_backend(backend, merged)
	:ok = update_env(:logger, key, merged)
	end

	defp configure({_, key, _, merged}) do
	Logger.configure([{key, merged}])
	:ok = update_env(:logger, key, merged)
	end

	defp update({group, key, value, merged}) do
	try do
	:ok = update_env(group, key, merged)

	if group != :pleroma or pleroma_need_restart?(group, key, value), do: group
	rescue
	error ->
	error_msg =
	"updating env causes error, group: #{inspect(group)}, key: #{inspect(key)}, value: #{
	inspect(value)
	} error: #{inspect(error)}"

	Logger.warn(error_msg)

	nil
	end
	end

	defp update_env(group, key, nil), do: Application.delete_env(group, key)
	defp update_env(group, key, value), do: Application.put_env(group, key, value)

	@spec pleroma_need_restart?(atom(), atom(), any()) :: boolean()
	def pleroma_need_restart?(group, key, value) do
	group_and_key_need_reboot?(group, key) or group_and_subkey_need_reboot?(group, key, value)
	end

	defp group_and_key_need_reboot?(group, key) do
	Enum.any?(@reboot_time_keys, fn {g, k} -> g == group and k == key end)
	end

	defp group_and_subkey_need_reboot?(group, key, value) do
	Keyword.keyword?(value) and
	Enum.any?(@reboot_time_subkeys, fn {g, k, subkeys} ->
	g == group and k == key and
	Enum.any?(Keyword.keys(value), &(&1 in subkeys))
	end)
	end

	defp restart(_, :pleroma, env), do: Restarter.Pleroma.restart_after_boot(env)

	defp restart(started_applications, app, _) do
	with {^app, _, _} <- List.keyfind(started_applications, app, 0),
	:ok <- Application.stop(app) do
	:ok = Application.start(app)
	else
	nil ->
	Logger.warn("#{app} is not started.")

	error ->
	error
	\|> inspect()
	\|> Logger.warn()
	end
	end

	defp can_be_merged?(val1, val2) when is_list(val1) and is_list(val2) do
	Keyword.keyword?(val1) and Keyword.keyword?(val2)
	end

	defp can_be_merged?(_val1, _val2), do: false
	end
	diff --git a/test/config/transfer_task_test.exs b/test/config/transfer_task_test.exs
	index 00db0b686..473899d1d 100644
	--- a/test/config/transfer_task_test.exs
	+++ b/test/config/transfer_task_test.exs
	@@ -1,175 +1,184 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.TransferTaskTest do
	use Pleroma.DataCase

	import ExUnit.CaptureLog

	alias Pleroma.Config.TransferTask
	alias Pleroma.ConfigDB

	setup do: clear_config(:configurable_from_database, true)

	test "transfer config values from db to env" do
	refute Application.get_env(:pleroma, :test_key)
	refute Application.get_env(:idna, :test_key)
	refute Application.get_env(:quack, :test_key)
	+ refute Application.get_env(:postgrex, :test_key)
	initial = Application.get_env(:logger, :level)

	ConfigDB.create(%{
	group: ":pleroma",
	key: ":test_key",
	value: [live: 2, com: 3]
	})

	ConfigDB.create(%{
	group: ":idna",
	key: ":test_key",
	value: [live: 15, com: 35]
	})

	ConfigDB.create(%{
	group: ":quack",
	key: ":test_key",
	value: [:test_value1, :test_value2]
	})

	+ ConfigDB.create(%{
	+ group: ":postgrex",
	+ key: ":test_key",
	+ value: :value
	+ })
	+
	ConfigDB.create(%{group: ":logger", key: ":level", value: :debug})

	TransferTask.start_link([])

	assert Application.get_env(:pleroma, :test_key) == [live: 2, com: 3]
	assert Application.get_env(:idna, :test_key) == [live: 15, com: 35]
	assert Application.get_env(:quack, :test_key) == [:test_value1, :test_value2]
	assert Application.get_env(:logger, :level) == :debug
	+ assert Application.get_env(:postgrex, :test_key) == :value

	on_exit(fn ->
	Application.delete_env(:pleroma, :test_key)
	Application.delete_env(:idna, :test_key)
	Application.delete_env(:quack, :test_key)
	+ Application.delete_env(:postgrex, :test_key)
	Application.put_env(:logger, :level, initial)
	end)
	end

	test "transfer config values for 1 group and some keys" do
	level = Application.get_env(:quack, :level)
	meta = Application.get_env(:quack, :meta)

	ConfigDB.create(%{
	group: ":quack",
	key: ":level",
	value: :info
	})

	ConfigDB.create(%{
	group: ":quack",
	key: ":meta",
	value: [:none]
	})

	TransferTask.start_link([])

	assert Application.get_env(:quack, :level) == :info
	assert Application.get_env(:quack, :meta) == [:none]
	default = Pleroma.Config.Holder.default_config(:quack, :webhook_url)
	assert Application.get_env(:quack, :webhook_url) == default

	on_exit(fn ->
	Application.put_env(:quack, :level, level)
	Application.put_env(:quack, :meta, meta)
	end)
	end

	test "transfer config values with full subkey update" do
	clear_config(:emoji)
	clear_config(:assets)

	ConfigDB.create(%{
	group: ":pleroma",
	key: ":emoji",
	value: [groups: [a: 1, b: 2]]
	})

	ConfigDB.create(%{
	group: ":pleroma",
	key: ":assets",
	value: [mascots: [a: 1, b: 2]]
	})

	TransferTask.start_link([])

	emoji_env = Application.get_env(:pleroma, :emoji)
	assert emoji_env[:groups] == [a: 1, b: 2]
	assets_env = Application.get_env(:pleroma, :assets)
	assert assets_env[:mascots] == [a: 1, b: 2]
	end

	describe "pleroma restart" do
	setup do
	on_exit(fn -> Restarter.Pleroma.refresh() end)
	end

	test "don't restart if no reboot time settings were changed" do
	clear_config(:emoji)

	ConfigDB.create(%{
	group: ":pleroma",
	key: ":emoji",
	value: [groups: [a: 1, b: 2]]
	})

	refute String.contains?(
	capture_log(fn -> TransferTask.start_link([]) end),
	"pleroma restarted"
	)
	end

	test "on reboot time key" do
	clear_config(:chat)

	ConfigDB.create(%{
	group: ":pleroma",
	key: ":chat",
	value: [enabled: false]
	})

	assert capture_log(fn -> TransferTask.start_link([]) end) =~ "pleroma restarted"
	end

	test "on reboot time subkey" do
	clear_config(Pleroma.Captcha)

	ConfigDB.create(%{
	group: ":pleroma",
	key: "Pleroma.Captcha",
	value: [seconds_valid: 60]
	})

	assert capture_log(fn -> TransferTask.start_link([]) end) =~ "pleroma restarted"
	end

	test "don't restart pleroma on reboot time key and subkey if there is false flag" do
	clear_config(:chat)
	clear_config(Pleroma.Captcha)

	ConfigDB.create(%{
	group: ":pleroma",
	key: ":chat",
	value: [enabled: false]
	})

	ConfigDB.create(%{
	group: ":pleroma",
	key: "Pleroma.Captcha",
	value: [seconds_valid: 60]
	})

	refute String.contains?(
	capture_log(fn -> TransferTask.load_and_update_env([], false) end),
	"pleroma restarted"
	)
	end
	end
	end
	diff --git a/test/fixtures/config/temp.secret.exs b/test/fixtures/config/temp.secret.exs
	index f4686c101..dc950ca30 100644
	--- a/test/fixtures/config/temp.secret.exs
	+++ b/test/fixtures/config/temp.secret.exs
	@@ -1,9 +1,11 @@
	use Mix.Config

	config :pleroma, :first_setting, key: "value", key2: [Pleroma.Repo]

	config :pleroma, :second_setting, key: "value2", key2: ["Activity"]

	config :quack, level: :info

	config :pleroma, Pleroma.Repo, pool: Ecto.Adapters.SQL.Sandbox
	+
	+config :postgrex, :json_library, Poison
	diff --git a/test/tasks/config_test.exs b/test/tasks/config_test.exs
	index 3dee4f082..04bc947a9 100644
	--- a/test/tasks/config_test.exs
	+++ b/test/tasks/config_test.exs
	@@ -1,194 +1,195 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.ConfigTest do
	use Pleroma.DataCase

	alias Pleroma.ConfigDB
	alias Pleroma.Repo

	setup_all do
	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	Application.delete_env(:pleroma, :first_setting)
	Application.delete_env(:pleroma, :second_setting)
	end)

	:ok
	end

	setup_all do: clear_config(:configurable_from_database, true)

	test "error if file with custom settings doesn't exist" do
	Mix.Tasks.Pleroma.Config.migrate_to_db("config/not_existance_config_file.exs")

	assert_receive {:mix_shell, :info,
	[
	"To migrate settings, you must define custom settings in config/not_existance_config_file.exs."
	]},
	15
	end

	describe "migrate_to_db/1" do
	setup do
	initial = Application.get_env(:quack, :level)
	on_exit(fn -> Application.put_env(:quack, :level, initial) end)
	end

	- test "settings are migrated to db" do
	+ test "filtered settings are migrated to db" do
	assert Repo.all(ConfigDB) == []

	Mix.Tasks.Pleroma.Config.migrate_to_db("test/fixtures/config/temp.secret.exs")

	config1 = ConfigDB.get_by_params(%{group: ":pleroma", key: ":first_setting"})
	config2 = ConfigDB.get_by_params(%{group: ":pleroma", key: ":second_setting"})
	config3 = ConfigDB.get_by_params(%{group: ":quack", key: ":level"})
	refute ConfigDB.get_by_params(%{group: ":pleroma", key: "Pleroma.Repo"})
	+ refute ConfigDB.get_by_params(%{group: ":postgrex", key: ":json_library"})

	assert ConfigDB.from_binary(config1.value) == [key: "value", key2: [Repo]]
	assert ConfigDB.from_binary(config2.value) == [key: "value2", key2: ["Activity"]]
	assert ConfigDB.from_binary(config3.value) == :info
	end

	test "config table is truncated before migration" do
	ConfigDB.create(%{
	group: ":pleroma",
	key: ":first_setting",
	value: [key: "value", key2: ["Activity"]]
	})

	assert Repo.aggregate(ConfigDB, :count, :id) == 1

	Mix.Tasks.Pleroma.Config.migrate_to_db("test/fixtures/config/temp.secret.exs")

	config = ConfigDB.get_by_params(%{group: ":pleroma", key: ":first_setting"})
	assert ConfigDB.from_binary(config.value) == [key: "value", key2: [Repo]]
	end
	end

	describe "with deletion temp file" do
	setup do
	temp_file = "config/temp.exported_from_db.secret.exs"

	on_exit(fn ->
	:ok = File.rm(temp_file)
	end)

	{:ok, temp_file: temp_file}
	end

	test "settings are migrated to file and deleted from db", %{temp_file: temp_file} do
	ConfigDB.create(%{
	group: ":pleroma",
	key: ":setting_first",
	value: [key: "value", key2: ["Activity"]]
	})

	ConfigDB.create(%{
	group: ":pleroma",
	key: ":setting_second",
	value: [key: "value2", key2: [Repo]]
	})

	ConfigDB.create(%{group: ":quack", key: ":level", value: :info})

	Mix.Tasks.Pleroma.Config.run(["migrate_from_db", "--env", "temp", "-d"])

	assert Repo.all(ConfigDB) == []

	file = File.read!(temp_file)
	assert file =~ "config :pleroma, :setting_first,"
	assert file =~ "config :pleroma, :setting_second,"
	assert file =~ "config :quack, :level, :info"
	end

	test "load a settings with large values and pass to file", %{temp_file: temp_file} do
	ConfigDB.create(%{
	group: ":pleroma",
	key: ":instance",
	value: [
	name: "Pleroma",
	email: "example@example.com",
	notify_email: "noreply@example.com",
	description: "A Pleroma instance, an alternative fediverse server",
	limit: 5_000,
	chat_limit: 5_000,
	remote_limit: 100_000,
	upload_limit: 16_000_000,
	avatar_upload_limit: 2_000_000,
	background_upload_limit: 4_000_000,
	banner_upload_limit: 4_000_000,
	poll_limits: %{
	max_options: 20,
	max_option_chars: 200,
	min_expiration: 0,
	max_expiration: 365 * 24 * 60 * 60
	},
	registrations_open: true,
	federating: true,
	federation_incoming_replies_max_depth: 100,
	federation_reachability_timeout_days: 7,
	federation_publisher_modules: [Pleroma.Web.ActivityPub.Publisher],
	allow_relay: true,
	rewrite_policy: Pleroma.Web.ActivityPub.MRF.NoOpPolicy,
	public: true,
	quarantined_instances: [],
	managed_config: true,
	static_dir: "instance/static/",
	allowed_post_formats: ["text/plain", "text/html", "text/markdown", "text/bbcode"],
	mrf_transparency: true,
	mrf_transparency_exclusions: [],
	autofollowed_nicknames: [],
	max_pinned_statuses: 1,
	attachment_links: false,
	welcome_user_nickname: nil,
	welcome_message: nil,
	max_report_comment_size: 1000,
	safe_dm_mentions: false,
	healthcheck: false,
	remote_post_retention_days: 90,
	skip_thread_containment: true,
	limit_to_local_content: :unauthenticated,
	user_bio_length: 5000,
	user_name_length: 100,
	max_account_fields: 10,
	max_remote_account_fields: 20,
	account_field_name_length: 512,
	account_field_value_length: 2048,
	external_user_synchronization: true,
	extended_nickname_format: true,
	multi_factor_authentication: [
	totp: [
	# digits 6 or 8
	digits: 6,
	period: 30
	],
	backup_codes: [
	number: 2,
	length: 6
	]
	]
	]
	})

	Mix.Tasks.Pleroma.Config.run(["migrate_from_db", "--env", "temp", "-d"])

	assert Repo.all(ConfigDB) == []
	assert File.exists?(temp_file)
	{:ok, file} = File.read(temp_file)

	header =
	if Code.ensure_loaded?(Config.Reader) do
	"import Config"
	else
	"use Mix.Config"
	end

	assert file ==
	"#{header}\n\nconfig :pleroma, :instance,\n name: \"Pleroma\",\n email: \"example@example.com\",\n notify_email: \"noreply@example.com\",\n description: \"A Pleroma instance, an alternative fediverse server\",\n limit: 5000,\n chat_limit: 5000,\n remote_limit: 100_000,\n upload_limit: 16_000_000,\n avatar_upload_limit: 2_000_000,\n background_upload_limit: 4_000_000,\n banner_upload_limit: 4_000_000,\n poll_limits: %{\n max_expiration: 31_536_000,\n max_option_chars: 200,\n max_options: 20,\n min_expiration: 0\n },\n registrations_open: true,\n federating: true,\n federation_incoming_replies_max_depth: 100,\n federation_reachability_timeout_days: 7,\n federation_publisher_modules: [Pleroma.Web.ActivityPub.Publisher],\n allow_relay: true,\n rewrite_policy: Pleroma.Web.ActivityPub.MRF.NoOpPolicy,\n public: true,\n quarantined_instances: [],\n managed_config: true,\n static_dir: \"instance/static/\",\n allowed_post_formats: [\"text/plain\", \"text/html\", \"text/markdown\", \"text/bbcode\"],\n mrf_transparency: true,\n mrf_transparency_exclusions: [],\n autofollowed_nicknames: [],\n max_pinned_statuses: 1,\n attachment_links: false,\n welcome_user_nickname: nil,\n welcome_message: nil,\n max_report_comment_size: 1000,\n safe_dm_mentions: false,\n healthcheck: false,\n remote_post_retention_days: 90,\n skip_thread_containment: true,\n limit_to_local_content: :unauthenticated,\n user_bio_length: 5000,\n user_name_length: 100,\n max_account_fields: 10,\n max_remote_account_fields: 20,\n account_field_name_length: 512,\n account_field_value_length: 2048,\n external_user_synchronization: true,\n extended_nickname_format: true,\n multi_factor_authentication: [\n totp: [digits: 6, period: 30],\n backup_codes: [number: 2, length: 6]\n ]\n"
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Fri, Aug 28, 10:56 AM (4 h, 50 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1736365
Default Alt Text: (22 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions