X-Git-Url: https://git.squeep.com/?a=blobdiff_plain;ds=sidebyside;f=lib%2Fpleroma%2Freverse_proxy.ex;h=91cf1bba33006f9947421e5799ad869144cf68de;hb=8d17287e2d223abaab31ccfd0ad0b7e5447aeac1;hp=de0f6e1bc6ed73caec4b481bd81565745f89c367;hpb=52b1b0e45dbc0835cc81530cae0e85cb1264c905;p=akkoma
diff --git a/lib/pleroma/reverse_proxy.ex b/lib/pleroma/reverse_proxy.ex
index de0f6e1bc..91cf1bba3 100644
--- a/lib/pleroma/reverse_proxy.ex
+++ b/lib/pleroma/reverse_proxy.ex
@@ -1,22 +1,27 @@
# Pleroma: A lightweight social networking server
-# Copyright © 2017-2019 Pleroma Authors
+# Copyright © 2017-2021 Pleroma Authors
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.ReverseProxy do
- alias Pleroma.HTTP
-
- @keep_req_headers ~w(accept user-agent accept-encoding cache-control if-modified-since) ++
- ~w(if-unmodified-since if-none-match if-range range)
- @resp_cache_headers ~w(etag date last-modified cache-control)
+ @range_headers ~w(range if-range)
+ @keep_req_headers ~w(accept accept-encoding cache-control if-modified-since) ++
+ ~w(if-unmodified-since if-none-match) ++ @range_headers
+ @resp_cache_headers ~w(etag date last-modified)
@keep_resp_headers @resp_cache_headers ++
- ~w(content-type content-disposition content-encoding content-range) ++
- ~w(accept-ranges vary)
+ ~w(content-length content-type content-disposition content-encoding) ++
+ ~w(content-range accept-ranges vary expires)
@default_cache_control_header "public, max-age=1209600"
@valid_resp_codes [200, 206, 304]
@max_read_duration :timer.seconds(30)
@max_body_length :infinity
+ @failed_request_ttl :timer.seconds(60)
@methods ~w(GET HEAD)
+ @cachex Pleroma.Config.get([:cachex, :provider], Cachex)
+
+ def max_read_duration_default, do: @max_read_duration
+ def default_cache_control_header, do: @default_cache_control_header
+
@moduledoc """
A reverse proxy.
@@ -33,9 +38,6 @@ defmodule Pleroma.ReverseProxy do
* request: `#{inspect(@keep_req_headers)}`
* response: `#{inspect(@keep_resp_headers)}`
- If no caching headers (`#{inspect(@resp_cache_headers)}`) are returned by upstream, `cache-control` will be
- set to `#{inspect(@default_cache_control_header)}`.
-
Options:
* `redirect_on_failure` (default `false`). Redirects the client to the real remote URL if there's any HTTP
@@ -48,21 +50,16 @@ defmodule Pleroma.ReverseProxy do
* `max_read_duration` (default `#{inspect(@max_read_duration)}` ms): the total time the connection is allowed to
read from the remote upstream.
+ * `failed_request_ttl` (default `#{inspect(@failed_request_ttl)}` ms): the time the failed request is cached and cannot be retried.
+
* `inline_content_types`:
* `true` will not alter `content-disposition` (up to the upstream),
* `false` will add `content-disposition: attachment` to any request,
* a list of whitelisted content types
- * `keep_user_agent` will forward the client's user-agent to the upstream. This may be useful if the upstream is
- doing content transformation (encoding, â¦) depending on the request.
-
* `req_headers`, `resp_headers` additional headers.
- * `http`: options for [hackney](https://github.com/benoitc/hackney).
-
"""
- @default_hackney_options []
-
@inline_content_types [
"image/gif",
"image/jpeg",
@@ -80,9 +77,9 @@ defmodule Pleroma.ReverseProxy do
import Plug.Conn
@type option() ::
- {:keep_user_agent, boolean}
- | {:max_read_duration, :timer.time() | :infinity}
+ {:max_read_duration, :timer.time() | :infinity}
| {:max_body_length, non_neg_integer() | :infinity}
+ | {:failed_request_ttl, :timer.time() | :infinity}
| {:http, []}
| {:req_headers, [{String.t(), String.t()}]}
| {:resp_headers, [{String.t(), String.t()}]}
@@ -93,10 +90,7 @@ defmodule Pleroma.ReverseProxy do
def call(_conn, _url, _opts \\ [])
def call(conn = %{method: method}, url, opts) when method in @methods do
- hackney_opts =
- @default_hackney_options
- |> Keyword.merge(Keyword.get(opts, :http, []))
- |> HTTP.process_request_options()
+ client_opts = Keyword.get(opts, :http, [])
req_headers = build_req_headers(conn.req_headers, opts)
@@ -107,31 +101,52 @@ defmodule Pleroma.ReverseProxy do
opts
end
- with {:ok, code, headers, client} <- request(method, url, req_headers, hackney_opts),
- :ok <- header_length_constraint(headers, Keyword.get(opts, :max_body_length)) do
- response(conn, client, url, code, headers, opts)
+ with {:ok, nil} <- @cachex.get(:failed_proxy_url_cache, url),
+ {:ok, status, headers, body} <- request(method, url, req_headers, client_opts),
+ :ok <-
+ header_length_constraint(
+ headers,
+ Keyword.get(opts, :max_body_length, @max_body_length)
+ ) do
+ conn
+ |> put_private(:proxied_url, url)
+ |> response(body, status, headers, opts)
else
- {:ok, code, headers} ->
- head_response(conn, url, code, headers, opts)
+ {:ok, true} ->
+ conn
+ |> put_private(:proxied_url, url)
+ |> error_or_redirect(500, "Request failed", opts)
|> halt()
- {:error, {:invalid_http_response, code}} ->
- Logger.error("#{__MODULE__}: request to #{inspect(url)} failed with HTTP status #{code}")
+ {:ok, status, headers} ->
+ conn
+ |> put_private(:proxied_url, url)
+ |> head_response(status, headers, opts)
+ |> halt()
+
+ {:error, {:invalid_http_response, status}} ->
+ Logger.error(
+ "#{__MODULE__}: request to #{inspect(url)} failed with HTTP status #{status}"
+ )
+
+ track_failed_url(url, status, opts)
conn
+ |> put_private(:proxied_url, url)
|> error_or_redirect(
- url,
- code,
- "Request failed: " <> Plug.Conn.Status.reason_phrase(code),
+ status,
+ "Request failed: " <> Plug.Conn.Status.reason_phrase(status),
opts
)
|> halt()
{:error, error} ->
Logger.error("#{__MODULE__}: request to #{inspect(url)} failed: #{inspect(error)}")
+ track_failed_url(url, error, opts)
conn
- |> error_or_redirect(url, 500, "Request failed", opts)
+ |> put_private(:proxied_url, url)
+ |> error_or_redirect(500, "Request failed", opts)
|> halt()
end
end
@@ -142,86 +157,52 @@ defmodule Pleroma.ReverseProxy do
|> halt()
end
- defp request(method, url, headers, hackney_opts) do
+ defp request(method, url, headers, opts) do
Logger.debug("#{__MODULE__} #{method} #{url} #{inspect(headers)}")
method = method |> String.downcase() |> String.to_existing_atom()
- case hackney().request(method, url, headers, "", hackney_opts) do
- {:ok, code, headers, client} when code in @valid_resp_codes ->
- {:ok, code, downcase_headers(headers), client}
+ opts = opts ++ [receive_timeout: @max_read_duration]
+
+ case Pleroma.HTTP.request(method, url, "", headers, opts) do
+ {:ok, %Tesla.Env{status: status, headers: headers, body: body}}
+ when status in @valid_resp_codes ->
+ {:ok, status, downcase_headers(headers), body}
- {:ok, code, headers} when code in @valid_resp_codes ->
- {:ok, code, downcase_headers(headers)}
+ {:ok, %Tesla.Env{status: status, headers: headers}} when status in @valid_resp_codes ->
+ {:ok, status, downcase_headers(headers)}
- {:ok, code, _, _} ->
- {:error, {:invalid_http_response, code}}
+ {:ok, %Tesla.Env{status: status}} ->
+ {:error, {:invalid_http_response, status}}
{:error, error} ->
{:error, error}
end
end
- defp response(conn, client, url, status, headers, opts) do
- result =
- conn
- |> put_resp_headers(build_resp_headers(headers, opts))
- |> send_chunked(status)
- |> chunk_reply(client, opts)
-
- case result do
- {:ok, conn} ->
- halt(conn)
-
- {:error, :closed, conn} ->
- :hackney.close(client)
- halt(conn)
-
- {:error, error, conn} ->
- Logger.warn(
- "#{__MODULE__} request to #{url} failed while reading/chunking: #{inspect(error)}"
- )
+ defp response(conn, body, status, headers, opts) do
+ Logger.debug("#{__MODULE__} #{status} #{conn.private[:proxied_url]} #{inspect(headers)}")
- :hackney.close(client)
- halt(conn)
- end
+ conn
+ |> put_resp_headers(build_resp_headers(headers, opts))
+ |> send_resp(status, body)
end
- defp chunk_reply(conn, client, opts) do
- chunk_reply(conn, client, opts, 0, 0)
- end
+ defp head_response(conn, status, headers, opts) do
+ Logger.debug("#{__MODULE__} #{status} #{conn.private[:proxied_url]} #{inspect(headers)}")
- defp chunk_reply(conn, client, opts, sent_so_far, duration) do
- with {:ok, duration} <-
- check_read_duration(
- duration,
- Keyword.get(opts, :max_read_duration, @max_read_duration)
- ),
- {:ok, data} <- hackney().stream_body(client),
- {:ok, duration} <- increase_read_duration(duration),
- sent_so_far = sent_so_far + byte_size(data),
- :ok <- body_size_constraint(sent_so_far, Keyword.get(opts, :max_body_size)),
- {:ok, conn} <- chunk(conn, data) do
- chunk_reply(conn, client, opts, sent_so_far, duration)
- else
- :done -> {:ok, conn}
- {:error, error} -> {:error, error, conn}
- end
- end
-
- defp head_response(conn, _url, code, headers, opts) do
conn
|> put_resp_headers(build_resp_headers(headers, opts))
- |> send_resp(code, "")
+ |> send_resp(status, "")
end
- defp error_or_redirect(conn, url, code, body, opts) do
+ defp error_or_redirect(conn, status, body, opts) do
if Keyword.get(opts, :redirect_on_failure, false) do
conn
- |> Phoenix.Controller.redirect(external: url)
+ |> Phoenix.Controller.redirect(external: conn.private[:proxied_url])
|> halt()
else
conn
- |> send_resp(code, body)
+ |> send_resp(status, body)
|> halt
end
end
@@ -250,20 +231,19 @@ defmodule Pleroma.ReverseProxy do
headers
|> downcase_headers()
|> Enum.filter(fn {k, _} -> k in @keep_req_headers end)
- |> (fn headers ->
- headers = headers ++ Keyword.get(opts, :req_headers, [])
-
- if Keyword.get(opts, :keep_user_agent, false) do
- List.keystore(
- headers,
- "user-agent",
- 0,
- {"user-agent", Pleroma.Application.user_agent()}
- )
- else
- headers
- end
- end).()
+ |> build_req_range_or_encoding_header(opts)
+ |> Keyword.merge(Keyword.get(opts, :req_headers, []))
+ end
+
+ # Disable content-encoding if any @range_headers are requested (see #1823).
+ defp build_req_range_or_encoding_header(headers, _opts) do
+ range? = Enum.any?(headers, fn {header, _} -> Enum.member?(@range_headers, header) end)
+
+ if range? && List.keymember?(headers, "accept-encoding", 0) do
+ List.keydelete(headers, "accept-encoding", 0)
+ else
+ headers
+ end
end
defp build_resp_headers(headers, opts) do
@@ -271,21 +251,22 @@ defmodule Pleroma.ReverseProxy do
|> Enum.filter(fn {k, _} -> k in @keep_resp_headers end)
|> build_resp_cache_headers(opts)
|> build_resp_content_disposition_header(opts)
- |> (fn headers -> headers ++ Keyword.get(opts, :resp_headers, []) end).()
+ |> Keyword.merge(Keyword.get(opts, :resp_headers, []))
end
defp build_resp_cache_headers(headers, _opts) do
has_cache? = Enum.any?(headers, fn {k, _} -> k in @resp_cache_headers end)
- has_cache_control? = List.keymember?(headers, "cache-control", 0)
cond do
- has_cache? && has_cache_control? ->
- headers
-
has_cache? ->
- # There's caching header present but no cache-control -- we need to explicitely override it
- # to public as Plug defaults to "max-age=0, private, must-revalidate"
- List.keystore(headers, "cache-control", 0, {"cache-control", "public"})
+ # There's caching header present but no cache-control -- we need to set our own
+ # as Plug defaults to "max-age=0, private, must-revalidate"
+ List.keystore(
+ headers,
+ "cache-control",
+ 0,
+ {"cache-control", @default_cache_control_header}
+ )
true ->
List.keystore(
@@ -351,32 +332,14 @@ defmodule Pleroma.ReverseProxy do
defp header_length_constraint(_, _), do: :ok
- defp body_size_constraint(size, limit) when is_integer(limit) and limit > 0 and size >= limit do
- {:error, :body_too_large}
- end
-
- defp body_size_constraint(_, _), do: :ok
-
- defp check_read_duration(duration, max)
- when is_integer(duration) and is_integer(max) and max > 0 do
- if duration > max do
- {:error, :read_duration_exceeded}
- else
- {:ok, {duration, :erlang.system_time(:millisecond)}}
- end
- end
-
- defp check_read_duration(_, _), do: {:ok, :no_duration_limit, :no_duration_limit}
-
- defp increase_read_duration({previous_duration, started})
- when is_integer(previous_duration) and is_integer(started) do
- duration = :erlang.system_time(:millisecond) - started
- {:ok, previous_duration + duration}
- end
+ defp track_failed_url(url, error, opts) do
+ ttl =
+ unless error in [:body_too_large, 400, 204] do
+ Keyword.get(opts, :failed_request_ttl, @failed_request_ttl)
+ else
+ nil
+ end
- defp increase_read_duration(_) do
- {:ok, :no_duration_limit, :no_duration_limit}
+ @cachex.put(:failed_proxy_url_cache, url, true, ttl: ttl)
end
-
- defp hackney, do: Pleroma.Config.get(:hackney, :hackney)
end