X-Git-Url: http://git.squeep.com/?a=blobdiff_plain;f=lib%2Fpleroma%2Fhttp%2Fadapter_helper.ex;h=e5da3ffa8f03e9578f18152b5f238b1a81db91ab;hb=refs%2Fheads%2Fdevelop;hp=9ec3836b057122243b174201eecc08d9db92afb8;hpb=6931dbfa582f0e5360e74dffdceee1b9ed564b17;p=akkoma

diff --git a/lib/pleroma/http/adapter_helper.ex b/lib/pleroma/http/adapter_helper.ex
index 9ec3836b0..e5da3ffa8 100644
--- a/lib/pleroma/http/adapter_helper.ex
+++ b/lib/pleroma/http/adapter_helper.ex
@@ -1,110 +1,123 @@
 # Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
+# Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.HTTP.AdapterHelper do
   @moduledoc """
   Configure Tesla.Client with default and customized adapter options.
   """
-  @defaults [pool: :federation]
+  @defaults [name: MyFinch, pool_timeout: 5_000, receive_timeout: 5_000]
 
   @type proxy_type() :: :socks4 | :socks5
   @type host() :: charlist() | :inet.ip_address()
 
-  alias Pleroma.Config
   alias Pleroma.HTTP.AdapterHelper
   require Logger
 
-  @type proxy ::
-          {Connection.host(), pos_integer()}
-          | {Connection.proxy_type(), Connection.host(), pos_integer()}
+  @type proxy :: {Connection.proxy_type(), Connection.host(), pos_integer(), list()}
 
   @callback options(keyword(), URI.t()) :: keyword()
-  @callback get_conn(URI.t(), keyword()) :: {:ok, term()} | {:error, term()}
 
   @spec format_proxy(String.t() | tuple() | nil) :: proxy() | nil
   def format_proxy(nil), do: nil
 
   def format_proxy(proxy_url) do
     case parse_proxy(proxy_url) do
-      {:ok, host, port} -> {host, port}
-      {:ok, type, host, port} -> {type, host, port}
+      {:ok, type, host, port} -> {type, host, port, []}
       _ -> nil
     end
   end
 
   @spec maybe_add_proxy(keyword(), proxy() | nil) :: keyword()
   def maybe_add_proxy(opts, nil), do: opts
-  def maybe_add_proxy(opts, proxy), do: Keyword.put_new(opts, :proxy, proxy)
 
-  @doc """
-  Merge default connection & adapter options with received ones.
-  """
+  def maybe_add_proxy(opts, proxy) do
+    Keyword.put(opts, :proxy, proxy)
+  end
 
-  @spec options(URI.t(), keyword()) :: keyword()
-  def options(%URI{} = uri, opts \\ []) do
-    @defaults
-    |> put_timeout()
-    |> Keyword.merge(opts)
-    |> adapter_helper().options(uri)
+  def maybe_add_proxy_pool(opts, nil), do: opts
+
+  def maybe_add_proxy_pool(opts, proxy) do
+    Logger.info("Using HTTP Proxy: #{inspect(proxy)}")
+
+    opts
+    |> maybe_add_pools()
+    |> maybe_add_default_pool()
+    |> maybe_add_conn_opts()
+    |> put_in([:pools, :default, :conn_opts, :proxy], proxy)
+  end
+
+  def add_pool_size(opts, pool_size) do
+    opts
+    |> maybe_add_pools()
+    |> maybe_add_default_pool()
+    |> put_in([:pools, :default, :size], pool_size)
   end
 
-  # For Hackney, this is the time a connection can stay idle in the pool.
-  # For Gun, this is the timeout to receive a message from Gun.
-  defp put_timeout(opts) do
-    {config_key, default} =
-      if adapter() == Tesla.Adapter.Gun do
-        {:pools, Config.get([:pools, :default, :timeout], 5_000)}
-      else
-        {:hackney_pools, 10_000}
-      end
+  defp maybe_add_pools(opts) do
+    if Keyword.has_key?(opts, :pools) do
+      opts
+    else
+      Keyword.put(opts, :pools, %{})
+    end
+  end
 
-    timeout = Config.get([config_key, opts[:pool], :timeout], default)
+  defp maybe_add_default_pool(opts) do
+    pools = Keyword.get(opts, :pools)
 
-    Keyword.merge(opts, timeout: timeout)
+    if Map.has_key?(pools, :default) do
+      opts
+    else
+      put_in(opts, [:pools, :default], [])
+    end
   end
 
-  def get_conn(uri, opts), do: adapter_helper().get_conn(uri, opts)
-  defp adapter, do: Application.get_env(:tesla, :adapter)
+  defp maybe_add_conn_opts(opts) do
+    conn_opts = get_in(opts, [:pools, :default, :conn_opts])
 
-  defp adapter_helper do
-    case adapter() do
-      Tesla.Adapter.Gun -> AdapterHelper.Gun
-      Tesla.Adapter.Hackney -> AdapterHelper.Hackney
-      _ -> AdapterHelper.Default
+    unless is_nil(conn_opts) do
+      opts
+    else
+      put_in(opts, [:pools, :default, :conn_opts], [])
     end
   end
 
+  @doc """
+  Merge default connection & adapter options with received ones.
+  """
+
+  @spec options(URI.t(), keyword()) :: keyword()
+  def options(%URI{} = uri, opts \\ []) do
+    @defaults
+    |> Keyword.merge(opts)
+    |> AdapterHelper.Default.options(uri)
+  end
+
+  defp proxy_type("http"), do: {:ok, :http}
+  defp proxy_type("https"), do: {:ok, :https}
+  defp proxy_type(_), do: {:error, :unknown}
+
   @spec parse_proxy(String.t() | tuple() | nil) ::
-          {:ok, host(), pos_integer()}
-          | {:ok, proxy_type(), host(), pos_integer()}
+          {:ok, proxy_type(), host(), pos_integer()}
           | {:error, atom()}
           | nil
-
   def parse_proxy(nil), do: nil
+  def parse_proxy(""), do: nil
 
   def parse_proxy(proxy) when is_binary(proxy) do
-    with [host, port] <- String.split(proxy, ":"),
-         {port, ""} <- Integer.parse(port) do
-      {:ok, parse_host(host), port}
+    with %URI{} = uri <- URI.parse(proxy),
+         {:ok, type} <- proxy_type(uri.scheme) do
+      {:ok, type, uri.host, uri.port}
     else
-      {_, _} ->
-        Logger.warn("Parsing port failed #{inspect(proxy)}")
-        {:error, :invalid_proxy_port}
-
-      :error ->
-        Logger.warn("Parsing port failed #{inspect(proxy)}")
-        {:error, :invalid_proxy_port}
-
-      _ ->
-        Logger.warn("Parsing proxy failed #{inspect(proxy)}")
+      e ->
+        Logger.warn("Parsing proxy failed #{inspect(proxy)}, #{inspect(e)}")
         {:error, :invalid_proxy}
     end
   end
 
   def parse_proxy(proxy) when is_tuple(proxy) do
     with {type, host, port} <- proxy do
-      {:ok, type, parse_host(host), port}
+      {:ok, type, host, port}
     else
       _ ->
         Logger.warn("Parsing proxy failed #{inspect(proxy)}")