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