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