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   use Application
   7   import Supervisor.Spec
   8
   9   @name Mix.Project.config()[:name]
  10   @version Mix.Project.config()[:version]
  11   @repository Mix.Project.config()[:source_url]
  12   def name, do: @name
  13   def version, do: @version
  14   def named_version, do: @name <> " " <> @version
  15   def repository, do: @repository
  16
  17   def user_agent do
  18     info = "#{Pleroma.Web.base_url()} <#{Pleroma.Config.get([:instance, :email], "")}>"
  19     named_version() <> "; " <> info
  20   end
  21
  22   # See http://elixir-lang.org/docs/stable/elixir/Application.html
  23   # for more information on OTP Applications
  24   def start(_type, _args) do
  25     import Cachex.Spec
  26
  27     Pleroma.Config.DeprecationWarnings.warn()
  28     setup_instrumenters()
  29
  30     # Define workers and child supervisors to be supervised
  31     children =
  32       [
  33         # Start the Ecto repository
  34         supervisor(Pleroma.Repo, []),
  35         worker(Pleroma.Emoji, []),
  36         worker(Pleroma.Captcha, []),
  37         worker(
  38           Cachex,
  39           [
  40             :used_captcha_cache,
  41             [
  42               ttl_interval: :timer.seconds(Pleroma.Config.get!([Pleroma.Captcha, :seconds_valid]))
  43             ]
  44           ],
  45           id: :cachex_used_captcha_cache
  46         ),
  47         worker(
  48           Cachex,
  49           [
  50             :user_cache,
  51             [
  52               default_ttl: 25_000,
  53               ttl_interval: 1000,
  54               limit: 2500
  55             ]
  56           ],
  57           id: :cachex_user
  58         ),
  59         worker(
  60           Cachex,
  61           [
  62             :object_cache,
  63             [
  64               default_ttl: 25_000,
  65               ttl_interval: 1000,
  66               limit: 2500
  67             ]
  68           ],
  69           id: :cachex_object
  70         ),
  71         worker(
  72           Cachex,
  73           [
  74             :rich_media_cache,
  75             [
  76               default_ttl: :timer.minutes(120),
  77               limit: 5000
  78             ]
  79           ],
  80           id: :cachex_rich_media
  81         ),
  82         worker(
  83           Cachex,
  84           [
  85             :scrubber_cache,
  86             [
  87               limit: 2500
  88             ]
  89           ],
  90           id: :cachex_scrubber
  91         ),
  92         worker(
  93           Cachex,
  94           [
  95             :idempotency_cache,
  96             [
  97               expiration:
  98                 expiration(
  99                   default: :timer.seconds(6 * 60 * 60),
 100                   interval: :timer.seconds(60)
 101                 ),
 102               limit: 2500
 103             ]
 104           ],
 105           id: :cachex_idem
 106         ),
 107         worker(Pleroma.FlakeId, []),
 108         worker(Pleroma.ScheduledActivityWorker, [])
 109       ] ++
 110         hackney_pool_children() ++
 111         [
 112           worker(Pleroma.Web.Federator.RetryQueue, []),
 113           worker(Pleroma.Stats, []),
 114           worker(Task, [&Pleroma.Web.Push.init/0], restart: :temporary, id: :web_push_init),
 115           worker(Task, [&Pleroma.Web.Federator.init/0], restart: :temporary, id: :federator_init)
 116         ] ++
 117         streamer_child() ++
 118         chat_child() ++
 119         [
 120           # Start the endpoint when the application starts
 121           supervisor(Pleroma.Web.Endpoint, []),
 122           worker(Pleroma.Gopher.Server, [])
 123         ]
 124
 125     # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
 126     # for other strategies and supported options
 127     opts = [strategy: :one_for_one, name: Pleroma.Supervisor]
 128     Supervisor.start_link(children, opts)
 129   end
 130
 131   defp setup_instrumenters do
 132     require Prometheus.Registry
 133
 134     :ok =
 135       :telemetry.attach(
 136         "prometheus-ecto",
 137         [:pleroma, :repo, :query],
 138         &Pleroma.Repo.Instrumenter.handle_event/4,
 139         %{}
 140       )
 141
 142     Prometheus.Registry.register_collector(:prometheus_process_collector)
 143     Pleroma.Web.Endpoint.MetricsExporter.setup()
 144     Pleroma.Web.Endpoint.PipelineInstrumenter.setup()
 145     Pleroma.Web.Endpoint.Instrumenter.setup()
 146     Pleroma.Repo.Instrumenter.setup()
 147   end
 148
 149   def enabled_hackney_pools do
 150     [:media] ++
 151       if Application.get_env(:tesla, :adapter) == Tesla.Adapter.Hackney do
 152         [:federation]
 153       else
 154         []
 155       end ++
 156       if Pleroma.Config.get([Pleroma.Uploader, :proxy_remote]) do
 157         [:upload]
 158       else
 159         []
 160       end
 161   end
 162
 163   if Mix.env() == :test do
 164     defp streamer_child, do: []
 165     defp chat_child, do: []
 166   else
 167     defp streamer_child do
 168       [worker(Pleroma.Web.Streamer, [])]
 169     end
 170
 171     defp chat_child do
 172       if Pleroma.Config.get([:chat, :enabled]) do
 173         [worker(Pleroma.Web.ChatChannel.ChatChannelState, [])]
 174       else
 175         []
 176       end
 177     end
 178   end
 179
 180   defp hackney_pool_children do
 181     for pool <- enabled_hackney_pools() do
 182       options = Pleroma.Config.get([:hackney_pools, pool])
 183       :hackney_pool.child_spec(pool, options)
 184     end
 185   end
 186 end