git.squeep.com Git - akkoma/blob - lib/pleroma/application.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Application do
   6   use Application
   7
   8   import Cachex.Spec
   9
  10   alias Pleroma.Config
  11
  12   require Logger
  13
  14   @name Mix.Project.config()[:name]
  15   @version Mix.Project.config()[:version]
  16   @repository Mix.Project.config()[:source_url]
  17   @mix_env Mix.env()
  18
  19   def name, do: @name
  20   def version, do: @version
  21   def named_version, do: @name <> " " <> @version
  22   def repository, do: @repository
  23
  24   def user_agent do
  25     if Process.whereis(Pleroma.Web.Endpoint) do
  26       case Config.get([:http, :user_agent], :default) do
  27         :default ->
  28           info = "#{Pleroma.Web.Endpoint.url()} <#{Config.get([:instance, :email], "")}>"
  29           named_version() <> "; " <> info
  30
  31         custom ->
  32           custom
  33       end
  34     else
  35       # fallback, if endpoint is not started yet
  36       "Pleroma Data Loader"
  37     end
  38   end
  39
  40   # See http://elixir-lang.org/docs/stable/elixir/Application.html
  41   # for more information on OTP Applications
  42   def start(_type, _args) do
  43     # Scrubbers are compiled at runtime and therefore will cause a conflict
  44     # every time the application is restarted, so we disable module
  45     # conflicts at runtime
  46     Code.compiler_options(ignore_module_conflict: true)
  47     # Disable warnings_as_errors at runtime, it breaks Phoenix live reload
  48     # due to protocol consolidation warnings
  49     Code.compiler_options(warnings_as_errors: false)
  50     Config.Holder.save_default()
  51     Pleroma.HTML.compile_scrubbers()
  52     Pleroma.Config.Oban.warn()
  53     Config.DeprecationWarnings.warn()
  54     Pleroma.Web.Plugs.HTTPSecurityPlug.warn_if_disabled()
  55     Pleroma.ApplicationRequirements.verify!()
  56     setup_instrumenters()
  57     load_custom_modules()
  58     Pleroma.Docs.JSON.compile()
  59     limiters_setup()
  60
  61     Logger.info("Starting Finch")
  62     Finch.start_link(name: MyFinch)
  63
  64     # Define workers and child supervisors to be supervised
  65     children =
  66       [
  67         Pleroma.Repo,
  68         Config.TransferTask,
  69         Pleroma.Emoji,
  70         Pleroma.Web.Plugs.RateLimiter.Supervisor
  71       ] ++
  72         cachex_children() ++
  73         [
  74           Pleroma.Stats,
  75           Pleroma.JobQueueMonitor,
  76           {Majic.Pool, [name: Pleroma.MajicPool, pool_size: Config.get([:majic_pool, :size], 2)]},
  77           {Oban, Config.get(Oban)},
  78           Pleroma.Web.Endpoint
  79         ] ++
  80         elasticsearch_children() ++
  81         task_children(@mix_env) ++
  82         dont_run_in_test(@mix_env) ++
  83         shout_child(shout_enabled?())
  84
  85     # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
  86     # for other strategies and supported options
  87     opts = [strategy: :one_for_one, name: Pleroma.Supervisor]
  88     result = Supervisor.start_link(children, opts)
  89
  90     set_postgres_server_version()
  91
  92     result
  93   end
  94
  95   defp set_postgres_server_version do
  96     version =
  97       with %{rows: [[version]]} <- Ecto.Adapters.SQL.query!(Pleroma.Repo, "show server_version"),
  98            {num, _} <- Float.parse(version) do
  99         num
 100       else
 101         e ->
 102           Logger.warn(
 103             "Could not get the postgres version: #{inspect(e)}.\nSetting the default value of 9.6"
 104           )
 105
 106           9.6
 107       end
 108
 109     :persistent_term.put({Pleroma.Repo, :postgres_version}, version)
 110   end
 111
 112   def load_custom_modules do
 113     dir = Config.get([:modules, :runtime_dir])
 114
 115     if dir && File.exists?(dir) do
 116       dir
 117       |> Pleroma.Utils.compile_dir()
 118       |> case do
 119         {:error, _errors, _warnings} ->
 120           raise "Invalid custom modules"
 121
 122         {:ok, modules, _warnings} ->
 123           if @mix_env != :test do
 124             Enum.each(modules, fn mod ->
 125               Logger.info("Custom module loaded: #{inspect(mod)}")
 126             end)
 127           end
 128
 129           :ok
 130       end
 131     end
 132   end
 133
 134   defp setup_instrumenters do
 135     require Prometheus.Registry
 136
 137     if Application.get_env(:prometheus, Pleroma.Repo.Instrumenter) do
 138       :ok =
 139         :telemetry.attach(
 140           "prometheus-ecto",
 141           [:pleroma, :repo, :query],
 142           &Pleroma.Repo.Instrumenter.handle_event/4,
 143           %{}
 144         )
 145
 146       Pleroma.Repo.Instrumenter.setup()
 147     end
 148
 149     Pleroma.Web.Endpoint.MetricsExporter.setup()
 150     Pleroma.Web.Endpoint.PipelineInstrumenter.setup()
 151
 152     # Note: disabled until prometheus-phx is integrated into prometheus-phoenix:
 153     # Pleroma.Web.Endpoint.Instrumenter.setup()
 154     PrometheusPhx.setup()
 155   end
 156
 157   defp cachex_children do
 158     [
 159       build_cachex("used_captcha", ttl_interval: seconds_valid_interval()),
 160       build_cachex("user", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
 161       build_cachex("object", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
 162       build_cachex("rich_media", default_ttl: :timer.minutes(120), limit: 5000),
 163       build_cachex("scrubber", limit: 2500),
 164       build_cachex("idempotency", expiration: idempotency_expiration(), limit: 2500),
 165       build_cachex("web_resp", limit: 2500),
 166       build_cachex("emoji_packs", expiration: emoji_packs_expiration(), limit: 10),
 167       build_cachex("failed_proxy_url", limit: 2500),
 168       build_cachex("banned_urls", default_ttl: :timer.hours(24 * 30), limit: 5_000),
 169       build_cachex("chat_message_id_idempotency_key",
 170         expiration: chat_message_id_idempotency_key_expiration(),
 171         limit: 500_000
 172       )
 173     ]
 174   end
 175
 176   defp emoji_packs_expiration,
 177     do: expiration(default: :timer.seconds(5 * 60), interval: :timer.seconds(60))
 178
 179   defp idempotency_expiration,
 180     do: expiration(default: :timer.seconds(6 * 60 * 60), interval: :timer.seconds(60))
 181
 182   defp chat_message_id_idempotency_key_expiration,
 183     do: expiration(default: :timer.minutes(2), interval: :timer.seconds(60))
 184
 185   defp seconds_valid_interval,
 186     do: :timer.seconds(Config.get!([Pleroma.Captcha, :seconds_valid]))
 187
 188   @spec build_cachex(String.t(), keyword()) :: map()
 189   def build_cachex(type, opts),
 190     do: %{
 191       id: String.to_atom("cachex_" <> type),
 192       start: {Cachex, :start_link, [String.to_atom(type <> "_cache"), opts]},
 193       type: :worker
 194     }
 195
 196   defp shout_enabled?, do: Config.get([:shout, :enabled])
 197
 198   defp dont_run_in_test(env) when env in [:test, :benchmark], do: []
 199
 200   defp dont_run_in_test(_) do
 201     [
 202       {Registry,
 203        [
 204          name: Pleroma.Web.Streamer.registry(),
 205          keys: :duplicate,
 206          partitions: System.schedulers_online()
 207        ]}
 208     ] ++ background_migrators()
 209   end
 210
 211   defp background_migrators do
 212     [
 213       Pleroma.Migrators.HashtagsTableMigrator
 214     ]
 215   end
 216
 217   defp shout_child(true) do
 218     [
 219       Pleroma.Web.ShoutChannel.ShoutChannelState,
 220       {Phoenix.PubSub, [name: Pleroma.PubSub, adapter: Phoenix.PubSub.PG2]}
 221     ]
 222   end
 223
 224   defp shout_child(_), do: []
 225
 226   defp task_children(:test) do
 227     [
 228       %{
 229         id: :web_push_init,
 230         start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
 231         restart: :temporary
 232       }
 233     ]
 234   end
 235
 236   defp task_children(_) do
 237     [
 238       %{
 239         id: :web_push_init,
 240         start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
 241         restart: :temporary
 242       },
 243       %{
 244         id: :internal_fetch_init,
 245         start: {Task, :start_link, [&Pleroma.Web.ActivityPub.InternalFetchActor.init/0]},
 246         restart: :temporary
 247       }
 248     ]
 249   end
 250
 251   def elasticsearch_children do
 252     config = Config.get([Pleroma.Search, :module])
 253
 254     if config == Pleroma.Search.Elasticsearch do
 255       [Pleroma.Search.Elasticsearch.Cluster]
 256     else
 257       []
 258     end
 259   end
 260
 261   @spec limiters_setup() :: :ok
 262   def limiters_setup do
 263     config = Config.get(ConcurrentLimiter, [])
 264
 265     [
 266       Pleroma.Web.RichMedia.Helpers,
 267       Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy,
 268       Pleroma.Search
 269     ]
 270     |> Enum.each(fn module ->
 271       mod_config = Keyword.get(config, module, [])
 272
 273       max_running = Keyword.get(mod_config, :max_running, 5)
 274       max_waiting = Keyword.get(mod_config, :max_waiting, 5)
 275
 276       ConcurrentLimiter.new(module, max_running, max_waiting)
 277     end)
 278   end
 279 end