git.squeep.com Git - akkoma/blob - lib/pleroma/http/connection.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.HTTP.Connection do
   6   @moduledoc """
   7   Configure Tesla.Client with default and customized adapter options.
   8   """
   9   @type ip_address :: ipv4_address() | ipv6_address()
  10   @type ipv4_address :: {0..255, 0..255, 0..255, 0..255}
  11   @type ipv6_address ::
  12           {0..65_535, 0..65_535, 0..65_535, 0..65_535, 0..65_535, 0..65_535, 0..65_535, 0..65_535}
  13   @type proxy_type() :: :socks4 | :socks5
  14   @type host() :: charlist() | ip_address()
  15
  16   @defaults [pool: :federation]
  17
  18   require Logger
  19
  20   alias Pleroma.Config
  21   alias Pleroma.HTTP.Adapter
  22
  23   @doc """
  24   Merge default connection & adapter options with received ones.
  25   """
  26
  27   @spec options(URI.t(), keyword()) :: keyword()
  28   def options(%URI{} = uri, opts \\ []) do
  29     @defaults
  30     |> pool_timeout()
  31     |> Keyword.merge(opts)
  32     |> adapter().options(uri)
  33   end
  34
  35   defp pool_timeout(opts) do
  36     timeout =
  37       Config.get([:pools, opts[:pool], :timeout]) || Config.get([:pools, :default, :timeout])
  38
  39     Keyword.merge(opts, timeout: timeout)
  40   end
  41
  42   @spec after_request(keyword()) :: :ok
  43   def after_request(opts), do: adapter().after_request(opts)
  44
  45   defp adapter do
  46     case Application.get_env(:tesla, :adapter) do
  47       Tesla.Adapter.Gun -> Adapter.Gun
  48       Tesla.Adapter.Hackney -> Adapter.Hackney
  49       _ -> Adapter
  50     end
  51   end
  52
  53   @spec parse_proxy(String.t() | tuple() | nil) ::
  54           {:ok, host(), pos_integer()}
  55           | {:ok, proxy_type(), host(), pos_integer()}
  56           | {:error, atom()}
  57           | nil
  58
  59   def parse_proxy(nil), do: nil
  60
  61   def parse_proxy(proxy) when is_binary(proxy) do
  62     with [host, port] <- String.split(proxy, ":"),
  63          {port, ""} <- Integer.parse(port) do
  64       {:ok, parse_host(host), port}
  65     else
  66       {_, _} ->
  67         Logger.warn("parsing port in proxy fail #{inspect(proxy)}")
  68         {:error, :error_parsing_port_in_proxy}
  69
  70       :error ->
  71         Logger.warn("parsing port in proxy fail #{inspect(proxy)}")
  72         {:error, :error_parsing_port_in_proxy}
  73
  74       _ ->
  75         Logger.warn("parsing proxy fail #{inspect(proxy)}")
  76         {:error, :error_parsing_proxy}
  77     end
  78   end
  79
  80   def parse_proxy(proxy) when is_tuple(proxy) do
  81     with {type, host, port} <- proxy do
  82       {:ok, type, parse_host(host), port}
  83     else
  84       _ ->
  85         Logger.warn("parsing proxy fail #{inspect(proxy)}")
  86         {:error, :error_parsing_proxy}
  87     end
  88   end
  89
  90   @spec parse_host(String.t() | atom() | charlist()) :: charlist() | ip_address()
  91   def parse_host(host) when is_list(host), do: host
  92   def parse_host(host) when is_atom(host), do: to_charlist(host)
  93
  94   def parse_host(host) when is_binary(host) do
  95     host = to_charlist(host)
  96
  97     case :inet.parse_address(host) do
  98       {:error, :einval} -> host
  99       {:ok, ip} -> ip
 100     end
 101   end
 102 end