No OneTemporary
Actions

Size

40 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/application.ex b/lib/pleroma/application.ex
	index ce5b4f8d6..1e80c6249 100644
	--- a/lib/pleroma/application.ex
	+++ b/lib/pleroma/application.ex
	@@ -1,324 +1,318 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Application do
	use Application

	import Cachex.Spec

	alias Pleroma.Config

	require Logger

	@name Mix.Project.config()[:name]
	@version Mix.Project.config()[:version]
	@repository Mix.Project.config()[:source_url]

	def name, do: @name
	def version, do: @version
	def named_version, do: @name <> " " <> @version
	def repository, do: @repository

	def user_agent do
	if Process.whereis(Pleroma.Web.Endpoint) do
	case Config.get([:http, :user_agent], :default) do
	:default ->
	info = "#{Pleroma.Web.Endpoint.url()} <#{Config.get([:instance, :email], "")}>"
	named_version() <> "; " <> info

	custom ->
	custom
	end
	else
	# fallback, if endpoint is not started yet
	"Pleroma Data Loader"
	end
	end

	# See http://elixir-lang.org/docs/stable/elixir/Application.html
	# for more information on OTP Applications
	def start(_type, _args) do
	# Scrubbers are compiled at runtime and therefore will cause a conflict
	# every time the application is restarted, so we disable module
	# conflicts at runtime
	Code.compiler_options(ignore_module_conflict: true)
	configure_logger()
	Pleroma.Telemetry.Logger.attach()
	Config.Holder.save_default()
	Pleroma.HTML.compile_scrubbers()
	Pleroma.Config.Oban.warn()
	Config.DeprecationWarnings.warn()

	if Config.get([Pleroma.Web.Plugs.HTTPSecurityPlug, :enable], true) do
	Pleroma.Web.Plugs.HTTPSecurityPlug.warn_if_disabled()
	end

	if Config.get(:env) != :test do
	Pleroma.ApplicationRequirements.verify!()
	end

	load_custom_modules()
	Pleroma.Docs.JSON.compile()
	limiters_setup()

	adapter = Application.get_env(:tesla, :adapter)

	if match?({Tesla.Adapter.Finch, _}, adapter) do
	Logger.info("Starting Finch")
	Finch.start_link(name: MyFinch)
	end

	# Disable warnings_as_errors at runtime, it breaks Phoenix live reload
	# due to protocol consolidation warnings
	# :warnings_as_errors is deprecated via Code.compiler_options/2 since 1.18
	if Version.compare(System.version(), "1.18.0") == :lt do
	Code.compiler_options(warnings_as_errors: false)
	end

	# Define workers and child supervisors to be supervised
	children =
	[
	Pleroma.PromEx,
	Pleroma.LDAP,
	Pleroma.Repo,
	Config.TransferTask,
	Pleroma.Emoji,
	Pleroma.Web.Plugs.RateLimiter.Supervisor,
	{Task.Supervisor, name: Pleroma.TaskSupervisor}
	] ++
	cachex_children() ++
	http_children(adapter) ++
	[
	Pleroma.Stats,
	Pleroma.JobQueueMonitor,
	{Majic.Pool, [name: Pleroma.MajicPool, pool_size: Config.get([:majic_pool, :size], 2)]},
	{Oban, Config.get(Oban)},
	Pleroma.Web.Endpoint
	] ++
	task_children() ++
	streamer_registry() ++
	background_migrators() ++
	shout_child(shout_enabled?()) ++
	[Pleroma.Gopher.Server] ++
	[Pleroma.Search.Healthcheck]

	# See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
	# for other strategies and supported options
	# If we have a lot of caches, default max_restarts can cause test
	# resets to fail.
	# Go for the default 3 unless we're in test
	max_restarts = Application.get_env(:pleroma, __MODULE__)[:max_restarts]

	opts = [strategy: :one_for_one, name: Pleroma.Supervisor, max_restarts: max_restarts]
	Supervisor.start_link(children, opts)
	end

	def configure_logger do
	- if Application.get_env(:logger, :backends) do
	- Logger.warning(
	- "'config :logger, backends: [...]' is deprecated syntax due to changes in Elixir. Use 'config :pleroma, :logger, backends: [...]' instead."
	- )
	- end
	-
	Config.get([:logger, :backends], [])
	\|> Enum.each(fn backend ->
	backend = backend_to_logger(backend)

	case LoggerBackends.add(backend) do
	{:ok, _} ->
	Logger.debug("Successfully added logger backend: #{inspect(backend)}")

	{:error, reason} ->
	Logger.error("Failed to add logger backend #{inspect(backend)}: #{inspect(reason)}")
	end
	end)
	end

	defp backend_to_logger({:ex_syslogger = backend, name}) do
	Logger.warning(
	"Configuration {:#{backend}, :#{name}} is incorrect. Use {ExSyslogger, :#{name}} instead!"
	)

	{ExSyslogger, name}
	end

	defp backend_to_logger(backend), do: backend

	def load_custom_modules do
	dir = Config.get([:modules, :runtime_dir])

	if dir && File.exists?(dir) do
	dir
	\|> Pleroma.Utils.compile_dir()
	\|> case do
	{:error, _errors, _warnings} ->
	raise "Invalid custom modules"

	{:ok, modules, _warnings} ->
	if Application.get_env(:pleroma, __MODULE__)[:load_custom_modules] do
	Enum.each(modules, fn mod ->
	Logger.info("Custom module loaded: #{inspect(mod)}")
	end)
	end

	:ok
	end
	end
	end

	defp cachex_children do
	[
	build_cachex("used_captcha", ttl_interval: seconds_valid_interval()),
	build_cachex("user", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	build_cachex("object", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
	build_cachex("rich_media", default_ttl: :timer.minutes(120), limit: 5000),
	build_cachex("scrubber", limit: 2500),
	build_cachex("scrubber_management", limit: 2500),
	build_cachex("idempotency", expiration: idempotency_expiration(), limit: 2500),
	build_cachex("web_resp", limit: 2500),
	build_cachex("emoji_packs", expiration: emoji_packs_expiration(), limit: 10),
	build_cachex("failed_proxy_url", limit: 2500),
	build_cachex("failed_media_helper_url", default_ttl: :timer.minutes(15), limit: 2_500),
	build_cachex("banned_urls", default_ttl: :timer.hours(24 * 30), limit: 5_000),
	build_cachex("chat_message_id_idempotency_key",
	expiration: chat_message_id_idempotency_key_expiration(),
	limit: 500_000
	),
	build_cachex("rel_me", limit: 2500),
	build_cachex("host_meta", default_ttl: :timer.minutes(120), limit: 5_000),
	build_cachex("translations", default_ttl: :timer.hours(24), limit: 5_000)
	]
	end

	defp emoji_packs_expiration,
	do: expiration(default: :timer.seconds(5 * 60), interval: :timer.seconds(60))

	defp idempotency_expiration,
	do: expiration(default: :timer.seconds(6 * 60 * 60), interval: :timer.seconds(60))

	defp chat_message_id_idempotency_key_expiration,
	do: expiration(default: :timer.minutes(2), interval: :timer.seconds(60))

	defp seconds_valid_interval,
	do: :timer.seconds(Config.get!([Pleroma.Captcha, :seconds_valid]))

	@spec build_cachex(String.t(), keyword()) :: map()
	def build_cachex(type, opts),
	do: %{
	id: String.to_atom("cachex_" <> type),
	start: {Cachex, :start_link, [String.to_atom(type <> "_cache"), opts]},
	type: :worker
	}

	defp shout_enabled?, do: Config.get([:shout, :enabled])

	defp streamer_registry do
	if Application.get_env(:pleroma, __MODULE__)[:streamer_registry] do
	[
	{Registry,
	[
	name: Pleroma.Web.Streamer.registry(),
	keys: :duplicate,
	partitions: System.schedulers_online()
	]}
	]
	else
	[]
	end
	end

	defp background_migrators do
	if Application.get_env(:pleroma, __MODULE__)[:background_migrators] do
	[
	Pleroma.Migrators.HashtagsTableMigrator,
	Pleroma.Migrators.ContextObjectsDeletionMigrator
	]
	else
	[]
	end
	end

	defp shout_child(true) do
	[
	Pleroma.Web.ShoutChannel.ShoutChannelState,
	{Phoenix.PubSub, [name: Pleroma.PubSub, adapter: Phoenix.PubSub.PG2]}
	]
	end

	defp shout_child(_), do: []

	defp task_children do
	children = [
	%{
	id: :web_push_init,
	start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
	restart: :temporary
	}
	]

	if Application.get_env(:pleroma, __MODULE__)[:internal_fetch] do
	children ++
	[
	%{
	id: :internal_fetch_init,
	start: {Task, :start_link, [&Pleroma.Web.ActivityPub.InternalFetchActor.init/0]},
	restart: :temporary
	}
	]
	else
	children
	end
	end

	# start hackney and gun pools in tests
	defp http_children(adapter) do
	if Application.get_env(:pleroma, __MODULE__)[:test_http_pools] do
	http_children_hackney() ++ http_children_gun()
	else
	cond do
	match?(Tesla.Adapter.Hackney, adapter) -> http_children_hackney()
	match?(Tesla.Adapter.Gun, adapter) -> http_children_gun()
	true -> []
	end
	end
	end

	defp http_children_hackney do
	pools = [:federation, :media]

	pools =
	if Config.get([Pleroma.Upload, :proxy_remote]) do
	[:upload \| pools]
	else
	pools
	end

	for pool <- pools do
	options = Config.get([:hackney_pools, pool])
	:hackney_pool.child_spec(pool, options)
	end
	end

	defp http_children_gun do
	Pleroma.Gun.ConnectionPool.children() ++
	[{Task, &Pleroma.HTTP.AdapterHelper.Gun.limiter_setup/0}]
	end

	@spec limiters_setup() :: :ok
	def limiters_setup do
	config = Config.get(ConcurrentLimiter, [])

	[
	Pleroma.Search
	]
	\|> Enum.each(fn module ->
	mod_config = Keyword.get(config, module, [])

	max_running = Keyword.get(mod_config, :max_running, 5)
	max_waiting = Keyword.get(mod_config, :max_waiting, 5)

	ConcurrentLimiter.new(module, max_running, max_waiting)
	end)
	end
	end
	diff --git a/lib/pleroma/config/deprecation_warnings.ex b/lib/pleroma/config/deprecation_warnings.ex
	index 58d164dc7..8dabd728f 100644
	--- a/lib/pleroma/config/deprecation_warnings.ex
	+++ b/lib/pleroma/config/deprecation_warnings.ex
	@@ -1,418 +1,433 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.DeprecationWarnings do
	alias Pleroma.Config

	require Logger
	alias Pleroma.Config

	@type config_namespace() :: atom() \| [atom()]
	@type config_map() :: {config_namespace(), config_namespace(), String.t()}

	@mrf_config_map [
	{[:instance, :rewrite_policy], [:mrf, :policies],
	"\n* `config :pleroma, :instance, rewrite_policy` is now `config :pleroma, :mrf, policies`"},
	{[:instance, :mrf_transparency], [:mrf, :transparency],
	"\n* `config :pleroma, :instance, mrf_transparency` is now `config :pleroma, :mrf, transparency`"},
	{[:instance, :mrf_transparency_exclusions], [:mrf, :transparency_exclusions],
	"\n* `config :pleroma, :instance, mrf_transparency_exclusions` is now `config :pleroma, :mrf, transparency_exclusions`"}
	]

	def check_exiftool_filter do
	filters = Config.get([Pleroma.Upload]) \|> Keyword.get(:filters, [])

	if Pleroma.Upload.Filter.Exiftool in filters do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	Your config is using Exiftool as a filter instead of Exiftool.StripLocation. This should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, Pleroma.Upload,
	filters: [Pleroma.Upload.Filter.Exiftool]
	```

	Is now


	```
	config :pleroma, Pleroma.Upload,
	filters: [Pleroma.Upload.Filter.Exiftool.StripLocation]
	```
	""")

	new_config =
	filters
	\|> Enum.map(fn
	Pleroma.Upload.Filter.Exiftool -> Pleroma.Upload.Filter.Exiftool.StripLocation
	filter -> filter
	end)

	Config.put([Pleroma.Upload, :filters], new_config)

	:error
	else
	:ok
	end
	end

	def check_simple_policy_tuples do
	has_strings =
	Config.get([:mrf_simple])
	\|> Enum.any?(fn {_, v} -> Enum.any?(v, &is_binary/1) end)

	if has_strings do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	Your config is using strings in the SimplePolicy configuration instead of tuples. They should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, :mrf_simple,
	media_removal: ["instance.tld"],
	media_nsfw: ["instance.tld"],
	federated_timeline_removal: ["instance.tld"],
	report_removal: ["instance.tld"],
	reject: ["instance.tld"],
	followers_only: ["instance.tld"],
	accept: ["instance.tld"],
	avatar_removal: ["instance.tld"],
	banner_removal: ["instance.tld"],
	reject_deletes: ["instance.tld"]
	```

	Is now


	```
	config :pleroma, :mrf_simple,
	media_removal: [{"instance.tld", "Reason for media removal"}],
	media_nsfw: [{"instance.tld", "Reason for media nsfw"}],
	federated_timeline_removal: [{"instance.tld", "Reason for federated timeline removal"}],
	report_removal: [{"instance.tld", "Reason for report removal"}],
	reject: [{"instance.tld", "Reason for reject"}],
	followers_only: [{"instance.tld", "Reason for followers only"}],
	accept: [{"instance.tld", "Reason for accept"}],
	avatar_removal: [{"instance.tld", "Reason for avatar removal"}],
	banner_removal: [{"instance.tld", "Reason for banner removal"}],
	reject_deletes: [{"instance.tld", "Reason for reject deletes"}]
	```
	""")

	new_config =
	Config.get([:mrf_simple])
	\|> Enum.map(fn {k, v} ->
	{k,
	Enum.map(v, fn
	{instance, reason} -> {instance, reason}
	instance -> {instance, ""}
	end)}
	end)

	Config.put([:mrf_simple], new_config)

	:error
	else
	:ok
	end
	end

	def check_quarantined_instances_tuples do
	has_strings = Config.get([:instance, :quarantined_instances]) \|> Enum.any?(&is_binary/1)

	if has_strings do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	Your config is using strings in the quarantined_instances configuration instead of tuples. They should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, :instance,
	quarantined_instances: ["instance.tld"]
	```

	Is now


	```
	config :pleroma, :instance,
	quarantined_instances: [{"instance.tld", "Reason for quarantine"}]
	```
	""")

	new_config =
	Config.get([:instance, :quarantined_instances])
	\|> Enum.map(fn
	{instance, reason} -> {instance, reason}
	instance -> {instance, ""}
	end)

	Config.put([:instance, :quarantined_instances], new_config)

	:error
	else
	:ok
	end
	end

	def check_transparency_exclusions_tuples do
	has_strings = Config.get([:mrf, :transparency_exclusions]) \|> Enum.any?(&is_binary/1)

	if has_strings do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	Your config is using strings in the transparency_exclusions configuration instead of tuples. They should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, :mrf,
	transparency_exclusions: ["instance.tld"]
	```

	Is now


	```
	config :pleroma, :mrf,
	transparency_exclusions: [{"instance.tld", "Reason to exclude transparency"}]
	```
	""")

	new_config =
	Config.get([:mrf, :transparency_exclusions])
	\|> Enum.map(fn
	{instance, reason} -> {instance, reason}
	instance -> {instance, ""}
	end)

	Config.put([:mrf, :transparency_exclusions], new_config)

	:error
	else
	:ok
	end
	end

	def check_hellthread_threshold do
	if Config.get([:mrf_hellthread, :threshold]) do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	You are using the old configuration mechanism for the hellthread filter. Please check config.md.
	""")

	:error
	else
	:ok
	end
	end

	def warn do
	[
	check_hellthread_threshold(),
	check_old_mrf_config(),
	check_media_proxy_whitelist_config(),
	check_welcome_message_config(),
	check_gun_pool_options(),
	check_activity_expiration_config(),
	check_remote_ip_plug_name(),
	check_uploaders_s3_public_endpoint(),
	check_old_chat_shoutbox(),
	check_quarantined_instances_tuples(),
	check_transparency_exclusions_tuples(),
	check_simple_policy_tuples(),
	- check_exiftool_filter()
	+ check_exiftool_filter(),
	+ check_deprecated_logger_config()
	]
	\|> Enum.reduce(:ok, fn
	:ok, :ok -> :ok
	_, _ -> :error
	end)
	end

	def check_welcome_message_config do
	instance_config = Pleroma.Config.get([:instance])

	use_old_config =
	Keyword.has_key?(instance_config, :welcome_user_nickname) or
	Keyword.has_key?(instance_config, :welcome_message)

	if use_old_config do
	Logger.error("""
	!!!DEPRECATION WARNING!!!
	Your config is using the old namespace for Welcome messages configuration. You need to convert to the new namespace. e.g.,
	\n* `config :pleroma, :instance, welcome_user_nickname` and `config :pleroma, :instance, welcome_message` are now equal to:
	\n* `config :pleroma, :welcome, direct_message: [enabled: true, sender_nickname: "NICKNAME", message: "Your welcome message"]`"
	""")

	:error
	else
	:ok
	end
	end

	def check_old_mrf_config do
	warning_preface = """
	!!!DEPRECATION WARNING!!!
	Your config is using old namespaces for MRF configuration. They should work for now, but you are advised to change to new namespaces to prevent possible issues later:
	"""

	move_namespace_and_warn(@mrf_config_map, warning_preface)
	end

	@spec move_namespace_and_warn([config_map()], String.t()) :: :ok \| :error
	def move_namespace_and_warn(config_map, warning_preface) do
	warning =
	Enum.reduce(config_map, "", fn
	{old, new, err_msg}, acc ->
	old_config = Config.get(old)

	if old_config do
	Config.put(new, old_config)
	acc <> err_msg
	else
	acc
	end
	end)

	if warning == "" do
	:ok
	else
	Logger.warning(warning_preface <> warning)
	:error
	end
	end

	@spec check_media_proxy_whitelist_config() :: :ok \| :error
	def check_media_proxy_whitelist_config do
	whitelist = Config.get([:media_proxy, :whitelist])

	if Enum.any?(whitelist, &(not String.starts_with?(&1, "http"))) do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	Your config is using old format (only domain) for MediaProxy whitelist option. Setting should work for now, but you are advised to change format to scheme with port to prevent possible issues later.
	""")

	:error
	else
	:ok
	end
	end

	def check_gun_pool_options do
	pool_config = Config.get(:connections_pool)

	if timeout = pool_config[:await_up_timeout] do
	Logger.warning("""
	!!!DEPRECATION WARNING!!!
	Your config is using old setting `config :pleroma, :connections_pool, await_up_timeout`. Please change to `config :pleroma, :connections_pool, connect_timeout` to ensure compatibility with future releases.
	""")

	Config.put(:connections_pool, Keyword.put_new(pool_config, :connect_timeout, timeout))
	end

	pools_configs = Config.get(:pools)

	warning_preface = """
	!!!DEPRECATION WARNING!!!
	Your config is using old setting name `timeout` instead of `recv_timeout` in pool settings. The setting will not take effect until updated.
	"""

	updated_config =
	Enum.reduce(pools_configs, [], fn {pool_name, config}, acc ->
	if timeout = config[:timeout] do
	Keyword.put(acc, pool_name, Keyword.put_new(config, :recv_timeout, timeout))
	else
	acc
	end
	end)

	if updated_config != [] do
	pool_warnings =
	updated_config
	\|> Keyword.keys()
	\|> Enum.map(fn pool_name ->
	"\n* `:timeout` options in #{pool_name} pool is now `:recv_timeout`"
	end)

	Logger.warning(Enum.join([warning_preface \| pool_warnings]))

	Config.put(:pools, updated_config)
	:error
	else
	:ok
	end
	end

	@spec check_activity_expiration_config() :: :ok \| :error
	def check_activity_expiration_config do
	warning_preface = """
	!!!DEPRECATION WARNING!!!
	Your config is using old namespace for activity expiration configuration. Setting should work for now, but you are advised to change to new namespace to prevent possible issues later:
	"""

	move_namespace_and_warn(
	[
	{Pleroma.ActivityExpiration, Pleroma.Workers.PurgeExpiredActivity,
	"\n* `config :pleroma, Pleroma.ActivityExpiration` is now `config :pleroma, Pleroma.Workers.PurgeExpiredActivity`"}
	],
	warning_preface
	)
	end

	@spec check_remote_ip_plug_name() :: :ok \| :error
	def check_remote_ip_plug_name do
	warning_preface = """
	!!!DEPRECATION WARNING!!!
	Your config is using old namespace for RemoteIp Plug. Setting should work for now, but you are advised to change to new namespace to prevent possible issues later:
	"""

	move_namespace_and_warn(
	[
	{Pleroma.Plugs.RemoteIp, Pleroma.Web.Plugs.RemoteIp,
	"\n* `config :pleroma, Pleroma.Plugs.RemoteIp` is now `config :pleroma, Pleroma.Web.Plugs.RemoteIp`"}
	],
	warning_preface
	)
	end

	@spec check_uploaders_s3_public_endpoint() :: :ok \| :error
	def check_uploaders_s3_public_endpoint do
	s3_config = Pleroma.Config.get([Pleroma.Uploaders.S3])

	use_old_config = Keyword.has_key?(s3_config, :public_endpoint)

	if use_old_config do
	Logger.error("""
	!!!DEPRECATION WARNING!!!
	Your config is using the old setting for controlling the URL of media uploaded to your S3 bucket.\n
	Please make the following change at your earliest convenience.\n
	\n* `config :pleroma, Pleroma.Uploaders.S3, public_endpoint` is now equal to:
	\n* `config :pleroma, Pleroma.Upload, base_url`
	""")

	:error
	else
	:ok
	end
	end

	@spec check_old_chat_shoutbox() :: :ok \| :error
	def check_old_chat_shoutbox do
	instance_config = Pleroma.Config.get([:instance])
	chat_config = Pleroma.Config.get([:chat]) \|\| []

	use_old_config =
	Keyword.has_key?(instance_config, :chat_limit) or
	Keyword.has_key?(chat_config, :enabled)

	if use_old_config do
	Logger.error("""
	!!!DEPRECATION WARNING!!!
	Your config is using the old namespace for the Shoutbox configuration. You need to convert to the new namespace. e.g.,
	\n* `config :pleroma, :chat, enabled` and `config :pleroma, :instance, chat_limit` are now equal to:
	\n* `config :pleroma, :shout, enabled` and `config :pleroma, :shout, limit`
	""")

	:error
	else
	:ok
	end
	end
	+
	+ @spec check_deprecated_logger_config() :: :ok \| :error
	+ def check_deprecated_logger_config() do
	+ if Application.get_env(:logger, :backends) do
	+ Logger.warning(
	+ "'config :logger, backends: [...]' is deprecated syntax due to changes in Elixir. " <>
	+ "Use 'config :pleroma, :logger, backends: [...]' instead."
	+ )
	+
	+ :error
	+ else
	+ :ok
	+ end
	+ end
	end
	diff --git a/test/pleroma/application_test.exs b/test/pleroma/application_test.exs
	index bff44f4ff..afe628732 100644
	--- a/test/pleroma/application_test.exs
	+++ b/test/pleroma/application_test.exs
	@@ -1,37 +1,22 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2026 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ApplicationTest do
	use Pleroma.DataCase

	import ExUnit.CaptureLog

	- # clear_config/2 can only manipulate env under :pleroma.
	- describe "config :logger, backends: []" do
	- setup do
	- Application.put_env(:logger, :backends, [:console, {ExSyslogger, :ex_syslogger}])
	-
	- on_exit(fn ->
	- Application.delete_env(:logger, :backends) end)
	- end
	-
	- test "warns on deprecated syntax" do
	- assert capture_log(fn -> Pleroma.Application.configure_logger() end) =~
	- "'config :logger, backends: [...]' is deprecated syntax due to changes in Elixir. Use 'config :pleroma, :logger, backends: [...]' instead."
	- end
	- end
	-
	describe "config :pleroma, :logger, backends: [{:ex_syslogger, :ex_syslogger}]" do
	setup do
	clear_config([:logger, :backends], [{:ex_syslogger, :ex_syslogger}])
	end

	test "is handled" do
	log = capture_log(fn -> Pleroma.Application.configure_logger() end)

	assert log =~ "Configuration {:ex_syslogger, :ex_syslogger} is incorrect. Use {ExSyslogger, :ex_syslogger} instead!"
	assert log =~ "Successfully added logger backend: {ExSyslogger, :ex_syslogger}"
	end
	end
	end
	diff --git a/test/pleroma/config/deprecation_warnings_test.exs b/test/pleroma/config/deprecation_warnings_test.exs
	index fca2324ff..1491f4ea3 100644
	--- a/test/pleroma/config/deprecation_warnings_test.exs
	+++ b/test/pleroma/config/deprecation_warnings_test.exs
	@@ -1,391 +1,406 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Config.DeprecationWarningsTest do
	use ExUnit.Case
	use Pleroma.Tests.Helpers

	import ExUnit.CaptureLog

	alias Pleroma.Config
	alias Pleroma.Config.DeprecationWarnings

	describe "filter exiftool" do
	test "gives warning when still used" do
	clear_config(
	[Pleroma.Upload, :filters],
	[Pleroma.Upload.Filter.Exiftool]
	)

	assert capture_log(fn -> DeprecationWarnings.check_exiftool_filter() end) =~
	"""
	!!!DEPRECATION WARNING!!!
	Your config is using Exiftool as a filter instead of Exiftool.StripLocation. This should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, Pleroma.Upload,
	filters: [Pleroma.Upload.Filter.Exiftool]
	```

	Is now


	```
	config :pleroma, Pleroma.Upload,
	filters: [Pleroma.Upload.Filter.Exiftool.StripLocation]
	```
	"""
	end

	test "changes setting to exiftool strip location" do
	clear_config(
	[Pleroma.Upload, :filters],
	[Pleroma.Upload.Filter.Exiftool, Pleroma.Upload.Filter.Exiftool.ReadDescription]
	)

	expected_config = [
	Pleroma.Upload.Filter.Exiftool.StripLocation,
	Pleroma.Upload.Filter.Exiftool.ReadDescription
	]

	capture_log(fn -> DeprecationWarnings.warn() end)

	assert Config.get([Pleroma.Upload]) \|> Keyword.get(:filters, []) == expected_config
	end

	test "doesn't give a warning with correct config" do
	clear_config(
	[Pleroma.Upload, :filters],
	[
	Pleroma.Upload.Filter.Exiftool.StripLocation,
	Pleroma.Upload.Filter.Exiftool.ReadDescription
	]
	)

	assert capture_log(fn -> DeprecationWarnings.check_exiftool_filter() end) == ""
	end
	end

	describe "simple policy tuples" do
	test "gives warning when there are still strings" do
	clear_config([:mrf_simple],
	media_removal: ["some.removal"],
	media_nsfw: ["some.nsfw"],
	federated_timeline_removal: ["some.tl.removal"],
	report_removal: ["some.report.removal"],
	reject: ["some.reject"],
	followers_only: ["some.followers.only"],
	accept: ["some.accept"],
	avatar_removal: ["some.avatar.removal"],
	banner_removal: ["some.banner.removal"],
	reject_deletes: ["some.reject.deletes"]
	)

	assert capture_log(fn -> DeprecationWarnings.check_simple_policy_tuples() end) =~
	"""
	!!!DEPRECATION WARNING!!!
	Your config is using strings in the SimplePolicy configuration instead of tuples. They should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, :mrf_simple,
	media_removal: ["instance.tld"],
	media_nsfw: ["instance.tld"],
	federated_timeline_removal: ["instance.tld"],
	report_removal: ["instance.tld"],
	reject: ["instance.tld"],
	followers_only: ["instance.tld"],
	accept: ["instance.tld"],
	avatar_removal: ["instance.tld"],
	banner_removal: ["instance.tld"],
	reject_deletes: ["instance.tld"]
	```

	Is now


	```
	config :pleroma, :mrf_simple,
	media_removal: [{"instance.tld", "Reason for media removal"}],
	media_nsfw: [{"instance.tld", "Reason for media nsfw"}],
	federated_timeline_removal: [{"instance.tld", "Reason for federated timeline removal"}],
	report_removal: [{"instance.tld", "Reason for report removal"}],
	reject: [{"instance.tld", "Reason for reject"}],
	followers_only: [{"instance.tld", "Reason for followers only"}],
	accept: [{"instance.tld", "Reason for accept"}],
	avatar_removal: [{"instance.tld", "Reason for avatar removal"}],
	banner_removal: [{"instance.tld", "Reason for banner removal"}],
	reject_deletes: [{"instance.tld", "Reason for reject deletes"}]
	```
	"""
	end

	test "transforms config to tuples" do
	clear_config([:mrf_simple],
	media_removal: ["some.removal", {"some.other.instance", "Some reason"}]
	)

	expected_config =
	{:media_removal, [{"some.removal", ""}, {"some.other.instance", "Some reason"}]}

	capture_log(fn -> DeprecationWarnings.warn() end)

	assert expected_config in Config.get([:mrf_simple])
	end

	test "doesn't give a warning with correct config" do
	clear_config([:mrf_simple],
	media_removal: [{"some.removal", ""}, {"some.other.instance", "Some reason"}]
	)

	assert capture_log(fn -> DeprecationWarnings.check_simple_policy_tuples() end) == ""
	end
	end

	describe "quarantined_instances tuples" do
	test "gives warning when there are still strings" do
	clear_config([:instance, :quarantined_instances], [
	{"domain.com", "some reason"},
	"somedomain.tld"
	])

	assert capture_log(fn -> DeprecationWarnings.check_quarantined_instances_tuples() end) =~
	"""
	!!!DEPRECATION WARNING!!!
	Your config is using strings in the quarantined_instances configuration instead of tuples. They should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, :instance,
	quarantined_instances: ["instance.tld"]
	```

	Is now


	```
	config :pleroma, :instance,
	quarantined_instances: [{"instance.tld", "Reason for quarantine"}]
	```
	"""
	end

	test "transforms config to tuples" do
	clear_config([:instance, :quarantined_instances], [
	{"domain.com", "some reason"},
	"some.tld"
	])

	expected_config = [{"domain.com", "some reason"}, {"some.tld", ""}]

	capture_log(fn -> DeprecationWarnings.warn() end)

	assert Config.get([:instance, :quarantined_instances]) == expected_config
	end

	test "doesn't give a warning with correct config" do
	clear_config([:instance, :quarantined_instances], [
	{"domain.com", "some reason"},
	{"some.tld", ""}
	])

	assert capture_log(fn -> DeprecationWarnings.check_quarantined_instances_tuples() end) == ""
	end
	end

	describe "transparency_exclusions tuples" do
	test "gives warning when there are still strings" do
	clear_config([:mrf, :transparency_exclusions], [
	{"domain.com", "some reason"},
	"somedomain.tld"
	])

	assert capture_log(fn -> DeprecationWarnings.check_transparency_exclusions_tuples() end) =~
	"""
	!!!DEPRECATION WARNING!!!
	Your config is using strings in the transparency_exclusions configuration instead of tuples. They should work for now, but you are advised to change to the new configuration to prevent possible issues later:

	```
	config :pleroma, :mrf,
	transparency_exclusions: ["instance.tld"]
	```

	Is now


	```
	config :pleroma, :mrf,
	transparency_exclusions: [{"instance.tld", "Reason to exclude transparency"}]
	```
	"""
	end

	test "transforms config to tuples" do
	clear_config([:mrf, :transparency_exclusions], [
	{"domain.com", "some reason"},
	"some.tld"
	])

	expected_config = [{"domain.com", "some reason"}, {"some.tld", ""}]

	capture_log(fn -> DeprecationWarnings.warn() end)

	assert Config.get([:mrf, :transparency_exclusions]) == expected_config
	end

	test "doesn't give a warning with correct config" do
	clear_config([:mrf, :transparency_exclusions], [
	{"domain.com", "some reason"},
	{"some.tld", ""}
	])

	assert capture_log(fn -> DeprecationWarnings.check_transparency_exclusions_tuples() end) ==
	""
	end
	end

	test "check_old_mrf_config/0" do
	clear_config([:instance, :rewrite_policy], [])
	clear_config([:instance, :mrf_transparency], true)
	clear_config([:instance, :mrf_transparency_exclusions], [])

	assert capture_log(fn -> DeprecationWarnings.check_old_mrf_config() end) =~
	"""
	!!!DEPRECATION WARNING!!!
	Your config is using old namespaces for MRF configuration. They should work for now, but you are advised to change to new namespaces to prevent possible issues later:

	* `config :pleroma, :instance, rewrite_policy` is now `config :pleroma, :mrf, policies`
	* `config :pleroma, :instance, mrf_transparency` is now `config :pleroma, :mrf, transparency`
	* `config :pleroma, :instance, mrf_transparency_exclusions` is now `config :pleroma, :mrf, transparency_exclusions`
	"""
	end

	test "move_namespace_and_warn/2" do
	old_group1 = [:group, :key]
	old_group2 = [:group, :key2]
	old_group3 = [:group, :key3]

	new_group1 = [:another_group, :key4]
	new_group2 = [:another_group, :key5]
	new_group3 = [:another_group, :key6]

	clear_config(old_group1, 1)
	clear_config(old_group2, 2)
	clear_config(old_group3, 3)

	clear_config(new_group1)
	clear_config(new_group2)
	clear_config(new_group3)

	config_map = [
	{old_group1, new_group1, "\n error :key"},
	{old_group2, new_group2, "\n error :key2"},
	{old_group3, new_group3, "\n error :key3"}
	]

	assert capture_log(fn ->
	DeprecationWarnings.move_namespace_and_warn(
	config_map,
	"Warning preface"
	)
	end) =~ "Warning preface\n error :key\n error :key2\n error :key3"

	assert Config.get(new_group1) == 1
	assert Config.get(new_group2) == 2
	assert Config.get(new_group3) == 3
	end

	test "check_media_proxy_whitelist_config/0" do
	clear_config([:media_proxy, :whitelist], ["https://example.com", "example2.com"])

	assert capture_log(fn ->
	DeprecationWarnings.check_media_proxy_whitelist_config()
	end) =~ "Your config is using old format (only domain) for MediaProxy whitelist option"
	end

	test "check_welcome_message_config/0" do
	clear_config([:instance, :welcome_user_nickname], "LainChan")

	assert capture_log(fn ->
	DeprecationWarnings.check_welcome_message_config()
	end) =~ "Your config is using the old namespace for Welcome messages configuration."
	end

	test "check_hellthread_threshold/0" do
	clear_config([:mrf_hellthread, :threshold], 16)

	assert capture_log(fn ->
	DeprecationWarnings.check_hellthread_threshold()
	end) =~ "You are using the old configuration mechanism for the hellthread filter."
	end

	test "check_activity_expiration_config/0" do
	clear_config([Pleroma.ActivityExpiration], enabled: true)

	assert capture_log(fn ->
	DeprecationWarnings.check_activity_expiration_config()
	end) =~ "Your config is using old namespace for activity expiration configuration."
	end

	test "check_uploaders_s3_public_endpoint/0" do
	clear_config([Pleroma.Uploaders.S3], public_endpoint: "https://fake.amazonaws.com/bucket/")

	assert capture_log(fn ->
	DeprecationWarnings.check_uploaders_s3_public_endpoint()
	end) =~
	"Your config is using the old setting for controlling the URL of media uploaded to your S3 bucket."
	end

	describe "check_gun_pool_options/0" do
	test "await_up_timeout" do
	config = Config.get(:connections_pool)
	clear_config(:connections_pool, Keyword.put(config, :await_up_timeout, 5_000))

	assert capture_log(fn ->
	DeprecationWarnings.check_gun_pool_options()
	end) =~
	"Your config is using old setting `config :pleroma, :connections_pool, await_up_timeout`."
	end

	test "pool timeout" do
	old_config = [
	federation: [
	size: 50,
	max_waiting: 10,
	timeout: 10_000
	],
	media: [
	size: 50,
	max_waiting: 10,
	timeout: 10_000
	],
	upload: [
	size: 25,
	max_waiting: 5,
	timeout: 15_000
	],
	default: [
	size: 10,
	max_waiting: 2,
	timeout: 5_000
	]
	]

	clear_config(:pools, old_config)

	assert capture_log(fn ->
	DeprecationWarnings.check_gun_pool_options()
	end) =~
	"Your config is using old setting name `timeout` instead of `recv_timeout` in pool settings"
	end
	end

	test "check_old_chat_shoutbox/0" do
	clear_config([:instance, :chat_limit], 1_000)
	clear_config([:chat, :enabled], true)

	assert capture_log(fn ->
	DeprecationWarnings.check_old_chat_shoutbox()
	end) =~
	"Your config is using the old namespace for the Shoutbox configuration."
	end
	+
	+ describe "check_deprecated_logger_config" do
	+ setup do
	+ Application.put_env(:logger, :backends, [:console, {ExSyslogger, :ex_syslogger}])
	+
	+ on_exit(fn ->
	+ Application.delete_env(:logger, :backends) end)
	+ end
	+
	+ test "warns on deprecated syntax" do
	+ assert capture_log(fn -> Pleroma.Config.DeprecationWarnings.check_deprecated_logger_config() end) =~
	+ "'config :logger, backends: [...]' is deprecated syntax due to changes in Elixir. Use 'config :pleroma, :logger, backends: [...]' instead."
	+ end
	+ end
	+
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 8, 5:03 PM (1 d, 22 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1723736
Default Alt Text: (40 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions