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