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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Application do
   6   import Cachex.Spec
   7   use Application
   8   require Logger
   9
  10   @name Mix.Project.config()[:name]
  11   @version Mix.Project.config()[:version]
  12   @repository Mix.Project.config()[:source_url]
  13   @env Mix.env()
  14
  15   def name, do: @name
  16   def version, do: @version
  17   def named_version, do: @name <> " " <> @version
  18   def repository, do: @repository
  19
  20   def user_agent do
  21     case Pleroma.Config.get([:http, :user_agent], :default) do
  22       :default ->
  23         info = "#{Pleroma.Web.base_url()} <#{Pleroma.Config.get([:instance, :email], "")}>"
  24         named_version() <> "; " <> info
  25
  26       custom ->
  27         custom
  28     end
  29   end
  30
  31   # See http://elixir-lang.org/docs/stable/elixir/Application.html
  32   # for more information on OTP Applications
  33   def start(_type, _args) do
  34     Pleroma.HTML.compile_scrubbers()
  35     Pleroma.Config.DeprecationWarnings.warn()
  36     Pleroma.Plugs.HTTPSecurityPlug.warn_if_disabled()
  37     Pleroma.Repo.check_migrations_applied!()
  38     setup_instrumenters()
  39     load_custom_modules()
  40
  41     # Define workers and child supervisors to be supervised
  42     children =
  43       [
  44         Pleroma.Repo,
  45         Pleroma.Scheduler,
  46         Pleroma.Config.TransferTask,
  47         Pleroma.Emoji,
  48         Pleroma.Captcha,
  49         Pleroma.Daemons.ScheduledActivityDaemon,
  50         Pleroma.Daemons.ActivityExpirationDaemon,
  51         Pleroma.Plugs.RateLimiter.Supervisor
  52       ] ++
  53         cachex_children() ++
  54         hackney_pool_children() ++
  55         [
  56           Pleroma.Stats,
  57           Pleroma.JobQueueMonitor,
  58           {Oban, Pleroma.Config.get(Oban)}
  59         ] ++
  60         task_children(@env) ++
  61         oauth_cleanup_child(oauth_cleanup_enabled?()) ++
  62         streamer_child(@env) ++
  63         chat_child(@env, chat_enabled?()) ++
  64         [
  65           Pleroma.Web.Endpoint,
  66           Pleroma.Gopher.Server
  67         ]
  68
  69     # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
  70     # for other strategies and supported options
  71     opts = [strategy: :one_for_one, name: Pleroma.Supervisor]
  72     Supervisor.start_link(children, opts)
  73   end
  74
  75   def load_custom_modules do
  76     dir = Pleroma.Config.get([:modules, :runtime_dir])
  77
  78     if dir && File.exists?(dir) do
  79       dir
  80       |> Pleroma.Utils.compile_dir()
  81       |> case do
  82         {:error, _errors, _warnings} ->
  83           raise "Invalid custom modules"
  84
  85         {:ok, modules, _warnings} ->
  86           if @env != :test do
  87             Enum.each(modules, fn mod ->
  88               Logger.info("Custom module loaded: #{inspect(mod)}")
  89             end)
  90           end
  91
  92           :ok
  93       end
  94     end
  95   end
  96
  97   defp setup_instrumenters do
  98     require Prometheus.Registry
  99
 100     if Application.get_env(:prometheus, Pleroma.Repo.Instrumenter) do
 101       :ok =
 102         :telemetry.attach(
 103           "prometheus-ecto",
 104           [:pleroma, :repo, :query],
 105           &Pleroma.Repo.Instrumenter.handle_event/4,
 106           %{}
 107         )
 108
 109       Pleroma.Repo.Instrumenter.setup()
 110     end
 111
 112     Pleroma.Web.Endpoint.MetricsExporter.setup()
 113     Pleroma.Web.Endpoint.PipelineInstrumenter.setup()
 114     Pleroma.Web.Endpoint.Instrumenter.setup()
 115   end
 116
 117   def enabled_hackney_pools do
 118     [:media] ++
 119       if Application.get_env(:tesla, :adapter) == Tesla.Adapter.Hackney do
 120         [:federation]
 121       else
 122         []
 123       end ++
 124       if Pleroma.Config.get([Pleroma.Upload, :proxy_remote]) do
 125         [:upload]
 126       else
 127         []
 128       end
 129   end
 130
 131   defp cachex_children do
 132     [
 133       build_cachex("used_captcha", ttl_interval: seconds_valid_interval()),
 134       build_cachex("user", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
 135       build_cachex("object", default_ttl: 25_000, ttl_interval: 1000, limit: 2500),
 136       build_cachex("rich_media", default_ttl: :timer.minutes(120), limit: 5000),
 137       build_cachex("scrubber", limit: 2500),
 138       build_cachex("idempotency", expiration: idempotency_expiration(), limit: 2500),
 139       build_cachex("web_resp", limit: 2500),
 140       build_cachex("emoji_packs", expiration: emoji_packs_expiration(), limit: 10),
 141       build_cachex("failed_proxy_url", limit: 2500)
 142     ]
 143   end
 144
 145   defp emoji_packs_expiration,
 146     do: expiration(default: :timer.seconds(5 * 60), interval: :timer.seconds(60))
 147
 148   defp idempotency_expiration,
 149     do: expiration(default: :timer.seconds(6 * 60 * 60), interval: :timer.seconds(60))
 150
 151   defp seconds_valid_interval,
 152     do: :timer.seconds(Pleroma.Config.get!([Pleroma.Captcha, :seconds_valid]))
 153
 154   defp build_cachex(type, opts),
 155     do: %{
 156       id: String.to_atom("cachex_" <> type),
 157       start: {Cachex, :start_link, [String.to_atom(type <> "_cache"), opts]},
 158       type: :worker
 159     }
 160
 161   defp chat_enabled?, do: Pleroma.Config.get([:chat, :enabled])
 162
 163   defp oauth_cleanup_enabled?,
 164     do: Pleroma.Config.get([:oauth2, :clean_expired_tokens], false)
 165
 166   defp streamer_child(:test), do: []
 167
 168   defp streamer_child(_) do
 169     [Pleroma.Web.Streamer.supervisor()]
 170   end
 171
 172   defp oauth_cleanup_child(true),
 173     do: [Pleroma.Web.OAuth.Token.CleanWorker]
 174
 175   defp oauth_cleanup_child(_), do: []
 176
 177   defp chat_child(_env, true) do
 178     [Pleroma.Web.ChatChannel.ChatChannelState]
 179   end
 180
 181   defp chat_child(_, _), do: []
 182
 183   defp hackney_pool_children do
 184     for pool <- enabled_hackney_pools() do
 185       options = Pleroma.Config.get([:hackney_pools, pool])
 186       :hackney_pool.child_spec(pool, options)
 187     end
 188   end
 189
 190   defp task_children(:test) do
 191     [
 192       %{
 193         id: :web_push_init,
 194         start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
 195         restart: :temporary
 196       }
 197     ]
 198   end
 199
 200   defp task_children(_) do
 201     [
 202       %{
 203         id: :web_push_init,
 204         start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
 205         restart: :temporary
 206       },
 207       %{
 208         id: :internal_fetch_init,
 209         start: {Task, :start_link, [&Pleroma.Web.ActivityPub.InternalFetchActor.init/0]},
 210         restart: :temporary
 211       }
 212     ]
 213   end
 214 end