Base cache off of plug_mint_proxy

The cache now bases itself off of the plug_mint_proxy, making it
slightly faster and somewhat easier to maintain.  It is now in line with
use on mu-dispatcher and mu-identifier.

Author: madnificent

lib/manipulators/cache_key_logger.ex

@@ -0,0 +1,47 @@
+defmodule Manipulators.CacheKeyLogger do
+  @moduledoc """
+    Manipulates the response, logging the cache keys and the clear keys
+    if this was requested by configuration.
+  """
+  @behaviour ProxyManipulator
+
+  @impl true
+  def headers(headers, _) do
+    maybe_log_cache_keys(headers)
+    maybe_log_clear_keys(headers)
+
+    :skip
+  end
+
+  @impl true
+  def chunk(_, _), do: :skip
+
+  @impl true
+  def finish(_, _), do: :skip
+
+  defp maybe_log_clear_keys(headers) do
+    if Application.get_env(:mu_cache, :log_clear_keys) do
+      clear_keys = header_value(headers, "clear-keys")
+
+      # credo:disable-for-next-line Credo.Check.Warning.IoInspect
+      IO.inspect(clear_keys, label: "Clear keys")
+    end
+  end
+
+  defp maybe_log_cache_keys(headers) do
+    if Application.get_env(:mu_cache, :log_cache_keys) do
+      cache_keys = header_value(headers, "cache-keys")
+
+      # credo:disable-for-next-line Credo.Check.Warning.IoInspect
+      IO.inspect(cache_keys, label: "Cache keys")
+    end
+  end
+
+  defp header_value(headers, header_name) do
+    header = Enum.find(headers, header_name)
+
+    if header do
+      elem(header, 1)
+    end
+  end
+end

lib/manipulators/remove_cache_related_keys.ex

@@ -0,0 +1,29 @@
+defmodule Manipulators.RemoveCacheRelatedKeys do
+  @moduledoc """
+  Removes cache-keys and clear-keys from the incoming connection.
+
+  The intended use for this is as a response manipulator, removing
+  cache keys and clear keys from the server response.
+  """
+
+  @behaviour ProxyManipulator
+
+  @impl true
+  def headers(headers, connection) do
+    new_headers =
+      headers
+      |> Enum.reject(fn
+        {"cache-keys", _} -> true
+        {"clear-keys", _} -> true
+        _ -> false
+      end)
+
+    {new_headers, connection}
+  end
+
+  @impl true
+  def chunk(_, _), do: :skip
+
+  @impl true
+  def finish(_, _), do: :skip
+end

lib/manipulators/store_response.ex

@@ -0,0 +1,122 @@
+defmodule Manipulators.StoreResponse do
+  alias Cache.Registry, as: Cache
+
+  @moduledoc """
+   Stores the response in a shared cache for reuse.
+
+   This manipulator must run as a response manipulator because it needs
+   the full response.
+
+   We store the information on what is `conn_out` in from this
+   manipulator's perspective as we can hopefully keep that alive in the
+   future, even when the client connection has dropped out.  Our
+   experimentation shows that to be the Mint request, thus the
+   connection to the `backend` hostname.
+  """
+
+  @behaviour ProxyManipulator
+
+  @impl true
+  def headers(headers, {conn_in, conn_out}) do
+    should_cache = Enum.any?(headers, &match?({"cache-keys", _}, &1))
+    should_clear = Enum.any?(headers, &match?({"clear-keys", _}, &1))
+
+    if should_cache or should_clear do
+      conn_out_with_headers =
+        conn_out
+        |> Mint.HTTP.put_private(:mu_cache_should_cache, should_cache)
+        |> Mint.HTTP.put_private(:mu_cache_should_clear, should_clear)
+        |> Mint.HTTP.put_private(:mu_cache_original_headers, headers)
+
+      {headers, {conn_in, conn_out_with_headers}}
+    else
+      :skip
+    end
+  end
+
+  @impl true
+  def chunk(chunk, {conn_in, conn_out}) do
+    should_cache = Mint.HTTP.get_private(conn_out, :mu_cache_should_cache)
+
+    if should_cache do
+      current_chunks = Mint.HTTP.get_private(conn_out, :mu_cache_chunks, [])
+      # reversed, see finish
+      new_chunks = [chunk | current_chunks]
+
+      conn_out_with_new_chunks = Mint.HTTP.put_private(conn_out, :mu_cache_chunks, new_chunks)
+
+      {chunk, {conn_in, conn_out_with_new_chunks}}
+    else
+      :skip
+    end
+  end
+
+  @impl true
+  def finish(_, {conn_in, conn_out}) do
+    has_cache = Mint.HTTP.get_private(conn_out, :mu_cache_should_cache)
+
+    cond do
+      has_cache ->
+        reversed_chunks = Mint.HTTP.get_private(conn_out, :mu_cache_chunks, [])
+        response_body = Enum.reduce(reversed_chunks, "", &(&1 <> &2))
+
+        all_response_headers = Mint.HTTP.get_private(conn_out, :mu_cache_original_headers)
+
+        allowed_groups =
+          all_response_headers
+          |> Enum.find({nil, "[]"}, &match?({"mu-auth-allowed-groups", _}, &1))
+          |> elem(1)
+
+        cache_keys =
+          all_response_headers
+          |> Enum.find({nil, "[]"}, &match?({"cache-keys", _}, &1))
+          |> elem(1)
+          |> Poison.decode!()
+
+        clear_keys =
+          all_response_headers
+          |> Enum.find({nil, "[]"}, &match?({"clear-keys", _}, &1))
+          |> elem(1)
+          |> Poison.decode!()
+
+        # IO.inspect( {conn_in.method, conn_in.request_path, conn_in.query_string, allowed_groups}, label: "Signature to store" )
+
+        Cache.store(
+          {conn_in.method, conn_in.request_path, conn_in.query_string, allowed_groups},
+          %{
+            body: response_body,
+            headers:
+              Enum.reject(all_response_headers, fn
+                {"cache-keys", _} -> true
+                {"clear-keys", _} -> true
+                _ -> false
+              end),
+            status_code: conn_in.status,
+            cache_keys: cache_keys,
+            clear_keys: clear_keys,
+            allowed_groups: allowed_groups
+          }
+        )
+
+      Mint.HTTP.get_private(conn_out, :mu_cache_should_clear) ->
+        # If we don't cache a response, we need to send the clear keys
+        # in another way.
+        all_response_headers = Mint.HTTP.get_private(conn_out, :mu_cache_original_headers)
+
+        clear_keys =
+          all_response_headers
+          |> Enum.find({nil, "[]"}, &match?({"clear-keys", _}, &1))
+          |> elem(1)
+          |> Poison.decode!()
+
+        IO.inspect(clear_keys, label: "Clear keys")
+
+        Cache.clear_keys(clear_keys)
+
+      true ->
+        nil
+    end
+
+    :skip
+  end
+end

lib/mu_cache_plug.ex

@@ -1,6 +1,6 @@
-alias Cache.Registry, as: Cache
-
 defmodule MuCachePlug do
+  alias Cache.Registry, as: Cache
+
   @moduledoc """
   Router for receiving cache requests.
   """
@@ -10,6 +10,17 @@ defmodule MuCachePlug do
   plug(:match)
   plug(:dispatch)
 
+  @request_manipulators []
+  @response_manipulators [
+    Manipulators.CacheKeyLogger,
+    Manipulators.StoreResponse,
+    Manipulators.RemoveCacheRelatedKeys
+  ]
+  @manipulators ProxyManipulatorSettings.make_settings(
+                  @request_manipulators,
+                  @response_manipulators
+                )
+
   get "/cachecanhasresponse" do
     send_resp(conn, 200, "debugging is a go")
   end
@@ -20,21 +31,22 @@ defmodule MuCachePlug do
     |> Enum.map(&Poison.decode!/1)
     # remove nil values
     |> Enum.filter(& &1)
-    |> Enum.map(&maybe_log_clear_keys/1)
+    |> Enum.map(&maybe_log_delta_clear_keys/1)
     |> Enum.map(&Cache.clear_keys/1)
 
     Plug.Conn.send_resp(conn, 204, "")
   end
 
   match "/*path" do
-    full_path = Enum.reduce(path, "", fn a, b -> b <> "/" <> a end)
+    full_path = conn.request_path
     known_allowed_groups = get_string_header(conn.req_headers, "mu-auth-allowed-groups")
     conn = Plug.Conn.fetch_query_params(conn)
 
     cond do
       known_allowed_groups == nil ->
         # without allowed groups, we don't know the access rights
-        calculate_response_from_backend(full_path, conn)
+        # calculate_response_from_backend(full_path, conn)
+        ConnectionForwarder.forward(conn, path, "http://backend/", @manipulators)
 
       cached_value =
           Cache.find_cache({conn.method, full_path, conn.query_string, known_allowed_groups}) ->
@@ -43,93 +55,11 @@ defmodule MuCachePlug do
 
       true ->
         # without a cache, we should consult the backend
-        IO.puts("Cache miss")
-        calculate_response_from_backend(full_path, conn)
-    end
-  end
-
-  defp maybe_log_clear_keys(clear_keys) do
-    if Application.get_env(:mu_cache, :log_clear_keys) do
-      # credo:disable-for-next-line Credo.Check.Warning.IoInspect
-      IO.inspect(clear_keys, label: "Clear keys")
-    end
-
-    clear_keys
-  end
+        # IO.inspect(
+        #   {conn.method, full_path, conn.query_string, known_allowed_groups}, label: "Cache miss for signature")
 
-  defp maybe_log_cache_keys(cache_keys) do
-    if Application.get_env(:mu_cache, :log_cache_keys) do
-      # credo:disable-for-next-line Credo.Check.Warning.IoInspect
-      IO.inspect(cache_keys, label: "Cache keys")
+        ConnectionForwarder.forward(conn, path, "http://backend/", @manipulators)
     end
-
-    cache_keys
-  end
-
-  @spec calculate_response_from_backend(String.t(), Plug.Conn.t()) :: Plug.Conn.t()
-  defp calculate_response_from_backend(full_path, conn) do
-    # Full path starts with /
-    url = "http://backend" <> full_path
-
-    url =
-      case conn.query_string do
-        "" -> url
-        query -> url <> "?" <> query
-      end
-
-    opts = PlugProxy.init(url: url)
-
-    processors = %{
-      header_processor: fn headers, _conn, state ->
-        headers = downcase_headers(headers)
-
-        {headers, cache_keys} = extract_json_header(headers, "cache-keys")
-        {headers, clear_keys} = extract_json_header(headers, "clear-keys")
-
-        maybe_log_cache_keys(cache_keys)
-        maybe_log_clear_keys(clear_keys)
-
-        {headers,
-         %{
-           state
-           | headers: headers,
-             allowed_groups: get_string_header(headers, "mu-auth-allowed-groups"),
-             cache_keys: cache_keys,
-             clear_keys: clear_keys
-         }}
-      end,
-      chunk_processor: fn chunk, state ->
-        # IO.puts "Received chunk:"
-        # IO.inspect chunk
-        {chunk, %{state | body: state.body <> chunk}}
-      end,
-      body_processor: fn body, state ->
-        # IO.puts "Received body:"
-        # IO.inspect body
-        {body, %{state | body: state.body <> body}}
-      end,
-      finish_hook: fn state ->
-        # IO.puts "Fully received body"
-        # IO.puts state.body
-        # IO.puts "Current state:"
-        # IO.inspect state
-        Cache.store({conn.method, full_path, conn.query_string, state.allowed_groups}, state)
-        {true, state}
-      end,
-      state: %{
-        is_processor_state: true,
-        body: "",
-        headers: %{},
-        status_code: 200,
-        cache_keys: [],
-        clear_keys: [],
-        allowed_groups: nil
-      }
-    }
-
-    conn
-    |> Map.put(:processors, processors)
-    |> PlugProxy.call(opts)
   end
 
   defp respond_with_cache(conn, cached_value) do
@@ -138,30 +68,16 @@ defmodule MuCachePlug do
     |> send_resp(200, cached_value.body)
   end
 
-  defp extract_json_header(headers, header_name) do
-    case List.keyfind(headers, header_name, 0) do
-      {^header_name, keys} ->
-        new_headers = List.keydelete(headers, header_name, 0)
-        {new_headers, Poison.decode!(keys)}
-
-      _ ->
-        {headers, []}
+  defp maybe_log_delta_clear_keys(clear_keys) do
+    if Application.get_env(:mu_cache, :log_clear_keys) do
+      # credo:disable-for-next-line Credo.Check.Warning.IoInspect
+      IO.inspect(clear_keys, label: "Clear keys")
     end
   end
 
   defp get_string_header(headers, header_name) do
-    case List.keyfind(headers, header_name, 0) do
-      {^header_name, string} ->
-        string
-
-      _ ->
-        nil
-    end
-  end
-
-  defp downcase_headers(headers) do
-    Enum.map(headers, fn {header, content} ->
-      {String.downcase(header), content}
-    end)
+    headers
+    |> List.keyfind(header_name, 0, {nil, nil})
+    |> elem(1)
   end
 end