git.squeep.com Git - akkoma/blob - lib/pleroma/http/adapter_helper.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.HTTP.AdapterHelper do
   6   @moduledoc """
   7   Configure Tesla.Client with default and customized adapter options.
   8   """
   9   @defaults [name: MyFinch, pool_timeout: 5_000, receive_timeout: 5_000]
  10
  11   @type proxy_type() :: :socks4 | :socks5
  12   @type host() :: charlist() | :inet.ip_address()
  13
  14   alias Pleroma.HTTP.AdapterHelper
  15   require Logger
  16
  17   @type proxy :: {Connection.proxy_type(), Connection.host(), pos_integer(), list()}
  18
  19   @callback options(keyword(), URI.t()) :: keyword()
  20
  21   @spec format_proxy(String.t() | tuple() | nil) :: proxy() | nil
  22   def format_proxy(nil), do: nil
  23
  24   def format_proxy(proxy_url) do
  25     case parse_proxy(proxy_url) do
  26       {:ok, type, host, port} -> {type, host, port, []}
  27       _ -> nil
  28     end
  29   end
  30
  31   @spec maybe_add_proxy(keyword(), proxy() | nil) :: keyword()
  32   def maybe_add_proxy(opts, nil), do: opts
  33
  34   def maybe_add_proxy(opts, proxy) do
  35     Keyword.put(opts, :proxy, proxy)
  36   end
  37
  38   def maybe_add_proxy_pool(opts, nil), do: opts
  39
  40   def maybe_add_proxy_pool(opts, proxy) do
  41     Logger.info("Using HTTP Proxy: #{inspect(proxy)}")
  42
  43     opts
  44     |> maybe_add_pools()
  45     |> maybe_add_default_pool()
  46     |> maybe_add_conn_opts()
  47     |> put_in([:pools, :default, :conn_opts, :proxy], proxy)
  48   end
  49
  50   def add_pool_size(opts, pool_size) do
  51     opts
  52     |> maybe_add_pools()
  53     |> maybe_add_default_pool()
  54     |> put_in([:pools, :default, :size], pool_size)
  55   end
  56
  57   defp maybe_add_pools(opts) do
  58     if Keyword.has_key?(opts, :pools) do
  59       opts
  60     else
  61       Keyword.put(opts, :pools, %{})
  62     end
  63   end
  64
  65   defp maybe_add_default_pool(opts) do
  66     pools = Keyword.get(opts, :pools)
  67
  68     if Map.has_key?(pools, :default) do
  69       opts
  70     else
  71       put_in(opts, [:pools, :default], [])
  72     end
  73   end
  74
  75   defp maybe_add_conn_opts(opts) do
  76     conn_opts = get_in(opts, [:pools, :default, :conn_opts])
  77
  78     unless is_nil(conn_opts) do
  79       opts
  80     else
  81       put_in(opts, [:pools, :default, :conn_opts], [])
  82     end
  83   end
  84
  85   @doc """
  86   Merge default connection & adapter options with received ones.
  87   """
  88
  89   @spec options(URI.t(), keyword()) :: keyword()
  90   def options(%URI{} = uri, opts \\ []) do
  91     @defaults
  92     |> Keyword.merge(opts)
  93     |> AdapterHelper.Default.options(uri)
  94   end
  95
  96   defp proxy_type("http"), do: {:ok, :http}
  97   defp proxy_type("https"), do: {:ok, :https}
  98   defp proxy_type(_), do: {:error, :unknown}
  99
 100   @spec parse_proxy(String.t() | tuple() | nil) ::
 101           {:ok, proxy_type(), host(), pos_integer()}
 102           | {:error, atom()}
 103           | nil
 104   def parse_proxy(nil), do: nil
 105   def parse_proxy(""), do: nil
 106
 107   def parse_proxy(proxy) when is_binary(proxy) do
 108     with %URI{} = uri <- URI.parse(proxy),
 109          {:ok, type} <- proxy_type(uri.scheme) do
 110       {:ok, type, uri.host, uri.port}
 111     else
 112       e ->
 113         Logger.warn("Parsing proxy failed #{inspect(proxy)}, #{inspect(e)}")
 114         {:error, :invalid_proxy}
 115     end
 116   end
 117
 118   def parse_proxy(proxy) when is_tuple(proxy) do
 119     with {type, host, port} <- proxy do
 120       {:ok, type, host, port}
 121     else
 122       _ ->
 123         Logger.warn("Parsing proxy failed #{inspect(proxy)}")
 124         {:error, :invalid_proxy}
 125     end
 126   end
 127
 128   @spec parse_host(String.t() | atom() | charlist()) :: charlist() | :inet.ip_address()
 129   def parse_host(host) when is_list(host), do: host
 130   def parse_host(host) when is_atom(host), do: to_charlist(host)
 131
 132   def parse_host(host) when is_binary(host) do
 133     host = to_charlist(host)
 134
 135     case :inet.parse_address(host) do
 136       {:error, :einval} -> host
 137       {:ok, ip} -> ip
 138     end
 139   end
 140
 141   @spec format_host(String.t()) :: charlist()
 142   def format_host(host) do
 143     host_charlist = to_charlist(host)
 144
 145     case :inet.parse_address(host_charlist) do
 146       {:error, :einval} ->
 147         :idna.encode(host_charlist)
 148
 149       {:ok, _ip} ->
 150         host_charlist
 151     end
 152   end
 153 end