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