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           id: Pleroma.ActivityExpirationWorker,
 121           start: {Pleroma.ActivityExpirationWorker, :start_link, []}
 122         }
 123       ] ++
 124         hackney_pool_children() ++
 125         [
 126           %{
 127             id: Pleroma.Web.Federator.RetryQueue,
 128             start: {Pleroma.Web.Federator.RetryQueue, :start_link, []}
 129           },
 130           %{
 131             id: Pleroma.Web.OAuth.Token.CleanWorker,
 132             start: {Pleroma.Web.OAuth.Token.CleanWorker, :start_link, []}
 133           },
 134           %{
 135             id: Pleroma.Stats,
 136             start: {Pleroma.Stats, :start_link, []}
 137           },
 138           %{
 139             id: :web_push_init,
 140             start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
 141             restart: :temporary
 142           },
 143           %{
 144             id: :federator_init,
 145             start: {Task, :start_link, [&Pleroma.Web.Federator.init/0]},
 146             restart: :temporary
 147           },
 148           %{
 149             id: :internal_fetch_init,
 150             start: {Task, :start_link, [&Pleroma.Web.ActivityPub.InternalFetchActor.init/0]},
 151             restart: :temporary
 152           }
 153         ] ++
 154         streamer_child() ++
 155         chat_child() ++
 156         [
 157           # Start the endpoint when the application starts
 158           %{
 159             id: Pleroma.Web.Endpoint,
 160             start: {Pleroma.Web.Endpoint, :start_link, []},
 161             type: :supervisor
 162           },
 163           %{id: Pleroma.Gopher.Server, start: {Pleroma.Gopher.Server, :start_link, []}}
 164         ]
 165
 166     # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
 167     # for other strategies and supported options
 168     opts = [strategy: :one_for_one, name: Pleroma.Supervisor]
 169     Supervisor.start_link(children, opts)
 170   end
 171
 172   defp setup_instrumenters do
 173     require Prometheus.Registry
 174
 175     if Application.get_env(:prometheus, Pleroma.Repo.Instrumenter) do
 176       :ok =
 177         :telemetry.attach(
 178           "prometheus-ecto",
 179           [:pleroma, :repo, :query],
 180           &Pleroma.Repo.Instrumenter.handle_event/4,
 181           %{}
 182         )
 183
 184       Pleroma.Repo.Instrumenter.setup()
 185     end
 186
 187     Pleroma.Web.Endpoint.MetricsExporter.setup()
 188     Pleroma.Web.Endpoint.PipelineInstrumenter.setup()
 189     Pleroma.Web.Endpoint.Instrumenter.setup()
 190   end
 191
 192   def enabled_hackney_pools do
 193     [:media] ++
 194       if Application.get_env(:tesla, :adapter) == Tesla.Adapter.Hackney do
 195         [:federation]
 196       else
 197         []
 198       end ++
 199       if Pleroma.Config.get([Pleroma.Upload, :proxy_remote]) do
 200         [:upload]
 201       else
 202         []
 203       end
 204   end
 205
 206   if Pleroma.Config.get(:env) == :test do
 207     defp streamer_child, do: []
 208     defp chat_child, do: []
 209   else
 210     defp streamer_child do
 211       [%{id: Pleroma.Web.Streamer, start: {Pleroma.Web.Streamer, :start_link, []}}]
 212     end
 213
 214     defp chat_child do
 215       if Pleroma.Config.get([:chat, :enabled]) do
 216         [
 217           %{
 218             id: Pleroma.Web.ChatChannel.ChatChannelState,
 219             start: {Pleroma.Web.ChatChannel.ChatChannelState, :start_link, []}
 220           }
 221         ]
 222       else
 223         []
 224       end
 225     end
 226   end
 227
 228   defp hackney_pool_children do
 229     for pool <- enabled_hackney_pools() do
 230       options = Pleroma.Config.get([:hackney_pools, pool])
 231       :hackney_pool.child_spec(pool, options)
 232     end
 233   end
 234 end