1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.HTTP.AdapterHelper do
7 Configure Tesla.Client with default and customized adapter options.
9 @defaults [name: MyFinch, pool_timeout: 5_000, receive_timeout: 5_000]
11 @type proxy_type() :: :socks4 | :socks5
12 @type host() :: charlist() | :inet.ip_address()
14 alias Pleroma.HTTP.AdapterHelper
17 @type proxy :: {Connection.proxy_type(), Connection.host(), pos_integer(), list()}
19 @callback options(keyword(), URI.t()) :: keyword()
21 @spec format_proxy(String.t() | tuple() | nil) :: proxy() | nil
22 def format_proxy(nil), do: nil
24 def format_proxy(proxy_url) do
25 case parse_proxy(proxy_url) do
26 {:ok, type, host, port} -> {type, host, port, []}
31 @spec maybe_add_proxy(keyword(), proxy() | nil) :: keyword()
32 def maybe_add_proxy(opts, nil), do: opts
34 def maybe_add_proxy(opts, proxy) do
35 Keyword.put(opts, :proxy, proxy)
38 def maybe_add_proxy_pool(opts, nil), do: opts
40 def maybe_add_proxy_pool(opts, proxy) do
41 Logger.info("Using HTTP Proxy: #{inspect(proxy)}")
45 |> maybe_add_default_pool()
46 |> maybe_add_conn_opts()
47 |> put_in([:pools, :default, :conn_opts, :proxy], proxy)
50 def add_pool_size(opts, pool_size) do
53 |> maybe_add_default_pool()
54 |> put_in([:pools, :default, :size], pool_size)
57 defp maybe_add_pools(opts) do
58 if Keyword.has_key?(opts, :pools) do
61 Keyword.put(opts, :pools, %{})
65 defp maybe_add_default_pool(opts) do
66 pools = Keyword.get(opts, :pools)
68 if Map.has_key?(pools, :default) do
71 put_in(opts, [:pools, :default], [])
75 defp maybe_add_conn_opts(opts) do
76 conn_opts = get_in(opts, [:pools, :default, :conn_opts])
78 unless is_nil(conn_opts) do
81 put_in(opts, [:pools, :default, :conn_opts], [])
86 Merge default connection & adapter options with received ones.
89 @spec options(URI.t(), keyword()) :: keyword()
90 def options(%URI{} = uri, opts \\ []) do
92 |> Keyword.merge(opts)
93 |> AdapterHelper.Default.options(uri)
96 defp proxy_type("http"), do: {:ok, :http}
97 defp proxy_type("https"), do: {:ok, :https}
98 defp proxy_type(_), do: {:error, :unknown}
100 @spec parse_proxy(String.t() | tuple() | nil) ::
101 {:ok, proxy_type(), host(), pos_integer()}
104 def parse_proxy(nil), do: nil
105 def parse_proxy(""), do: nil
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}
113 Logger.warn("Parsing proxy failed #{inspect(proxy)}, #{inspect(e)}")
114 {:error, :invalid_proxy}
118 def parse_proxy(proxy) when is_tuple(proxy) do
119 with {type, host, port} <- proxy do
120 {:ok, type, host, port}
123 Logger.warn("Parsing proxy failed #{inspect(proxy)}")
124 {:error, :invalid_proxy}
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)
132 def parse_host(host) when is_binary(host) do
133 host = to_charlist(host)
135 case :inet.parse_address(host) do
136 {:error, :einval} -> host
141 @spec format_host(String.t()) :: charlist()
142 def format_host(host) do
143 host_charlist = to_charlist(host)
145 case :inet.parse_address(host_charlist) do
147 :idna.encode(host_charlist)