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
  29     # Define workers and child supervisors to be supervised
  30     children =
  31       [
  32         # Start the Ecto repository
  33         supervisor(Pleroma.Repo, []),
  34         worker(Pleroma.Emoji, []),
  35         worker(Pleroma.Captcha, []),
  36         worker(
  37           Cachex,
  38           [
  39             :used_captcha_cache,
  40             [
  41               ttl_interval: :timer.seconds(Pleroma.Config.get!([Pleroma.Captcha, :seconds_valid]))
  42             ]
  43           ],
  44           id: :cachex_used_captcha_cache
  45         ),
  46         worker(
  47           Cachex,
  48           [
  49             :user_cache,
  50             [
  51               default_ttl: 25000,
  52               ttl_interval: 1000,
  53               limit: 2500
  54             ]
  55           ],
  56           id: :cachex_user
  57         ),
  58         worker(
  59           Cachex,
  60           [
  61             :object_cache,
  62             [
  63               default_ttl: 25000,
  64               ttl_interval: 1000,
  65               limit: 2500
  66             ]
  67           ],
  68           id: :cachex_object
  69         ),
  70         worker(
  71           Cachex,
  72           [
  73             :rich_media_cache,
  74             [
  75               default_ttl: :timer.minutes(120),
  76               limit: 5000
  77             ]
  78           ],
  79           id: :cachex_rich_media
  80         ),
  81         worker(
  82           Cachex,
  83           [
  84             :scrubber_cache,
  85             [
  86               limit: 2500
  87             ]
  88           ],
  89           id: :cachex_scrubber
  90         ),
  91         worker(
  92           Cachex,
  93           [
  94             :idempotency_cache,
  95             [
  96               expiration:
  97                 expiration(
  98                   default: :timer.seconds(6 * 60 * 60),
  99                   interval: :timer.seconds(60)
 100                 ),
 101               limit: 2500
 102             ]
 103           ],
 104           id: :cachex_idem
 105         ),
 106         worker(Pleroma.FlakeId, [])
 107       ] ++
 108         hackney_pool_children() ++
 109         [
 110           worker(Pleroma.Web.Federator.RetryQueue, []),
 111           worker(Pleroma.Stats, []),
 112           worker(Pleroma.Web.Push, []),
 113           worker(Pleroma.Jobs, []),
 114           worker(Task, [&Pleroma.Web.Federator.init/0], restart: :temporary)
 115         ] ++
 116         streamer_child() ++
 117         chat_child() ++
 118         [
 119           # Start the endpoint when the application starts
 120           supervisor(Pleroma.Web.Endpoint, []),
 121           worker(Pleroma.Gopher.Server, [])
 122         ]
 123
 124     # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
 125     # for other strategies and supported options
 126     opts = [strategy: :one_for_one, name: Pleroma.Supervisor]
 127     Supervisor.start_link(children, opts)
 128   end
 129
 130   def enabled_hackney_pools() do
 131     [:media] ++
 132       if Application.get_env(:tesla, :adapter) == Tesla.Adapter.Hackney do
 133         [:federation]
 134       else
 135         []
 136       end ++
 137       if Pleroma.Config.get([Pleroma.Uploader, :proxy_remote]) do
 138         [:upload]
 139       else
 140         []
 141       end
 142   end
 143
 144   if Mix.env() == :test do
 145     defp streamer_child(), do: []
 146     defp chat_child(), do: []
 147   else
 148     defp streamer_child() do
 149       [worker(Pleroma.Web.Streamer, [])]
 150     end
 151
 152     defp chat_child() do
 153       if Pleroma.Config.get([:chat, :enabled]) do
 154         [worker(Pleroma.Web.ChatChannel.ChatChannelState, [])]
 155       else
 156         []
 157       end
 158     end
 159   end
 160
 161   defp hackney_pool_children() do
 162     for pool <- enabled_hackney_pools() do
 163       options = Pleroma.Config.get([:hackney_pools, pool])
 164       :hackney_pool.child_spec(pool, options)
 165     end
 166   end
 167 end