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         worker(Pleroma.QuantumScheduler, [])
 110       ] ++
 111         hackney_pool_children() ++
 112         [
 113           worker(Pleroma.Web.Federator.RetryQueue, []),
 114           worker(Pleroma.Web.OAuth.Token.CleanWorker, []),
 115           worker(Pleroma.Stats, []),
 116           worker(Task, [&Pleroma.Web.Push.init/0], restart: :temporary, id: :web_push_init),
 117           worker(Task, [&Pleroma.Web.Federator.init/0], restart: :temporary, id: :federator_init)
 118         ] ++
 119         streamer_child() ++
 120         chat_child() ++
 121         [
 122           # Start the endpoint when the application starts
 123           supervisor(Pleroma.Web.Endpoint, []),
 124           worker(Pleroma.Gopher.Server, [])
 125         ]
 126
 127     # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
 128     # for other strategies and supported options
 129     opts = [strategy: :one_for_one, name: Pleroma.Supervisor]
 130     result = Supervisor.start_link(children, opts)
 131     :ok = after_supervisor_start()
 132     result
 133   end
 134
 135   defp setup_instrumenters do
 136     require Prometheus.Registry
 137
 138     if Application.get_env(:prometheus, Pleroma.Repo.Instrumenter) do
 139       :ok =
 140         :telemetry.attach(
 141           "prometheus-ecto",
 142           [:pleroma, :repo, :query],
 143           &Pleroma.Repo.Instrumenter.handle_event/4,
 144           %{}
 145         )
 146
 147       Pleroma.Repo.Instrumenter.setup()
 148     end
 149
 150     Prometheus.Registry.register_collector(:prometheus_process_collector)
 151     Pleroma.Web.Endpoint.MetricsExporter.setup()
 152     Pleroma.Web.Endpoint.PipelineInstrumenter.setup()
 153     Pleroma.Web.Endpoint.Instrumenter.setup()
 154   end
 155
 156   def enabled_hackney_pools do
 157     [:media] ++
 158       if Application.get_env(:tesla, :adapter) == Tesla.Adapter.Hackney do
 159         [:federation]
 160       else
 161         []
 162       end ++
 163       if Pleroma.Config.get([Pleroma.Uploader, :proxy_remote]) do
 164         [:upload]
 165       else
 166         []
 167       end
 168   end
 169
 170   if Mix.env() == :test do
 171     defp streamer_child, do: []
 172     defp chat_child, do: []
 173   else
 174     defp streamer_child do
 175       [worker(Pleroma.Web.Streamer, [])]
 176     end
 177
 178     defp chat_child do
 179       if Pleroma.Config.get([:chat, :enabled]) do
 180         [worker(Pleroma.Web.ChatChannel.ChatChannelState, [])]
 181       else
 182         []
 183       end
 184     end
 185   end
 186
 187   defp hackney_pool_children do
 188     for pool <- enabled_hackney_pools() do
 189       options = Pleroma.Config.get([:hackney_pools, pool])
 190       :hackney_pool.child_spec(pool, options)
 191     end
 192   end
 193
 194   defp after_supervisor_start do
 195     with digest_config <- Application.get_env(:pleroma, :email_notifications)[:digest],
 196          true <- digest_config[:active],
 197          %Crontab.CronExpression{} = schedule <-
 198            Crontab.CronExpression.Parser.parse!(digest_config[:schedule]) do
 199       Pleroma.QuantumScheduler.new_job()
 200       |> Quantum.Job.set_name(:digest_emails)
 201       |> Quantum.Job.set_schedule(schedule)
 202       |> Quantum.Job.set_task(&Pleroma.DigestEmailWorker.run/0)
 203       |> Pleroma.QuantumScheduler.add_job()
 204     end
 205
 206     :ok
 207   end
 208 end