Merge branch 'exclude-reblogs-from-admin-api-by-default' into 'develop'
[akkoma] / lib / pleroma / plugs / cache.ex
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
4
5 defmodule Pleroma.Plugs.Cache do
6 @moduledoc """
7 Caches successful GET responses.
8
9 To enable the cache add the plug to a router pipeline or controller:
10
11 plug(Pleroma.Plugs.Cache)
12
13 ## Configuration
14
15 To configure the plug you need to pass settings as the second argument to the `plug/2` macro:
16
17 plug(Pleroma.Plugs.Cache, [ttl: nil, query_params: true])
18
19 Available options:
20
21 - `ttl`: An expiration time (time-to-live). This value should be in milliseconds or `nil` to disable expiration. Defaults to `nil`.
22 - `query_params`: Take URL query string into account (`true`), ignore it (`false`) or limit to specific params only (list). Defaults to `true`.
23 - `tracking_fun`: A function that is called on successfull responses, no matter if the request is cached or not. It should accept a conn as the first argument and the value assigned to `tracking_fun_data` as the second.
24
25 Additionally, you can overwrite the TTL inside a controller action by assigning `cache_ttl` to the connection struct:
26
27 def index(conn, _params) do
28 ttl = 60_000 # one minute
29
30 conn
31 |> assign(:cache_ttl, ttl)
32 |> render("index.html")
33 end
34
35 """
36
37 import Phoenix.Controller, only: [current_path: 1, json: 2]
38 import Plug.Conn
39
40 @behaviour Plug
41
42 @defaults %{ttl: nil, query_params: true}
43
44 @impl true
45 def init([]), do: @defaults
46
47 def init(opts) do
48 opts = Map.new(opts)
49 Map.merge(@defaults, opts)
50 end
51
52 @impl true
53 def call(%{method: "GET"} = conn, opts) do
54 key = cache_key(conn, opts)
55
56 case Cachex.get(:web_resp_cache, key) do
57 {:ok, nil} ->
58 cache_resp(conn, opts)
59
60 {:ok, {content_type, body, tracking_fun_data}} ->
61 conn = opts.tracking_fun.(conn, tracking_fun_data)
62
63 send_cached(conn, {content_type, body})
64
65 {:ok, record} ->
66 send_cached(conn, record)
67
68 {atom, message} when atom in [:ignore, :error] ->
69 render_error(conn, message)
70 end
71 end
72
73 def call(conn, _), do: conn
74
75 # full path including query params
76 defp cache_key(conn, %{query_params: true}), do: current_path(conn)
77
78 # request path without query params
79 defp cache_key(conn, %{query_params: false}), do: conn.request_path
80
81 # request path with specific query params
82 defp cache_key(conn, %{query_params: query_params}) when is_list(query_params) do
83 query_string =
84 conn.params
85 |> Map.take(query_params)
86 |> URI.encode_query()
87
88 conn.request_path <> "?" <> query_string
89 end
90
91 defp cache_resp(conn, opts) do
92 register_before_send(conn, fn
93 %{status: 200, resp_body: body} = conn ->
94 ttl = Map.get(conn.assigns, :cache_ttl, opts.ttl)
95 key = cache_key(conn, opts)
96 content_type = content_type(conn)
97
98 conn =
99 unless opts[:tracking_fun] do
100 Cachex.put(:web_resp_cache, key, {content_type, body}, ttl: ttl)
101 conn
102 else
103 tracking_fun_data = Map.get(conn.assigns, :tracking_fun_data, nil)
104 Cachex.put(:web_resp_cache, key, {content_type, body, tracking_fun_data}, ttl: ttl)
105
106 opts.tracking_fun.(conn, tracking_fun_data)
107 end
108
109 put_resp_header(conn, "x-cache", "MISS from Pleroma")
110
111 conn ->
112 conn
113 end)
114 end
115
116 defp content_type(conn) do
117 conn
118 |> Plug.Conn.get_resp_header("content-type")
119 |> hd()
120 end
121
122 defp send_cached(conn, {content_type, body}) do
123 conn
124 |> put_resp_content_type(content_type, nil)
125 |> put_resp_header("x-cache", "HIT from Pleroma")
126 |> send_resp(:ok, body)
127 |> halt()
128 end
129
130 defp render_error(conn, message) do
131 conn
132 |> put_status(:internal_server_error)
133 |> json(%{error: message})
134 |> halt()
135 end
136 end