tompave

Plug: forward options to nested child plugs

UPDATE:
I originally forgot to mention that my `MainPlug` is a `Plug.Router`. I only realized it while responding to Overmind, below. I’ve now updated the initial message to make it clear.

Hello,

I’m working on a project where I have a main Plug that acts as the public API of the library. This module is a Plug.Router and it includes its own plug pipeline. Users are supposed to use it in their routers and forward traffic to it. Let’s call it MyPackage.MainPlug.

This main plug router then uses a number of child plugs to get some work done. These must be separate plugs, because the idea is that users can still use these building blocks to create their own router, if they need some custom logic.

My problem is that I can’t find a way to forward options to the nested “child” plugs.

For example, this is my Phoenix router, where I forward to my plug and pass some options to it:

defmodule MyPhoenixApp.Web.Router do
  use MyPhoenixApp.Web, :router

  pipeline :api do
    plug :accepts, ["json"]
  end

  scope path: "/stuff" do
    pipe_through :api
    forward "/", MyPackage.MainPlug, my_options: [foo: "foo", bar: "bar"]
  end
end

In the next snippet are my main plug (first) and the child plug (second):

defmodule MyPackage.MainPlug do
  use Plug.Router
  plug MyPackage.ChildPlug

  def init(opts) do
    opts # == [my_options: [foo: "foo", bar: "bar"]]
  end

  def call(conn, opts) do
    # opts == [my_options: [foo: "foo", bar: "bar"]]
    conn = Plug.Conn.assign(conn, :my_options, opts[:my_options])

    # do more stuff with conn
  end
end


defmodule MyPackage.ChildPlug do
  def init(opts) do
    opts # == []
  end

  def call(conn, opts) do
    # I need the extra options here!
    conn
  end
end

My problem is that I want to be able to customize ChildPlug from the outside, but I can’t find a clear way to do it.

As you can see, in MainPlug.call/2 I’m assigning the options to the conn just as an example, but it doesn’t really help me because, by then, ChildPlug has already been run.

I guess I could avoid the plug macro and invoke the child plugs directly in MainPlug.call/2, for example:

defmodule MyPackage.MainPlug do
  use Plug.Router
  alias MyPackage.PrivatePlug

  def init(opts) do
    opts # == [my_options: [foo: "foo", bar: "bar"]]
  end

  def call(conn, opts) do
    conn = PrivatePlug.call(conn, PrivatePlug.init(opts))

    # do more stuff with conn
  end
end

That would work, but I’d lose the nice performance gain of being able to manipulate the opts in the init function ahead of time.

Also, this seems a common enough requirement that hopefully there is already a clean API to do what I need.

Thanks!

10 comments

/phoenix #plug #how-to-question

12 3523 10

2024-11-20 01:25:58 UTC

Most Liked

tompave

Ok, I’ve finally had the time to work on this.

I think I’ve managed to implement what you described @OvermindDL1. It seems to work, thanks!

I’ll share it here in case it’s helpful to anyone else. I would also appreciate suggestions on how to improve it.

My plugs:

# A pair of simple plugs

defmodule DynamicPlugs.Foo do
  require Logger

  def init(opts) do
    Logger.debug "Foo.init(opts)        -> #{inspect opts}"
    Keyword.get(opts, :foo)
  end

  def call(conn, opts) do
    Logger.debug "Foo.call(conn, opts)  -> #{inspect opts}"
    conn
  end
end

defmodule DynamicPlugs.Bar do
  require Logger

  def init(opts) do
    Logger.debug "Bar.init(opts)        -> #{inspect opts}"
    Keyword.get(opts, :bar)
  end

  def call(conn, opts) do
    Logger.debug "Bar.call(conn, opts)  -> #{inspect opts}"
    conn
  end
end

# --------------------------------------------------------
# Main "public" plug

defmodule DynamicPlugs.Main do
  require Logger

  defmacrop do_build_dynamic_proxy(args) do
    quote do
      defmodule Proxy do
        use Plug.Builder

        plug DynamicPlugs.Foo, unquote(args)
        plug DynamicPlugs.Bar, unquote(args)
      end
    end
  end

  defp build_proxy(args) do
    {:module, proxy, _, _} = do_build_dynamic_proxy(args)
    proxy
  end

  def init(opts) do
    Logger.debug "Main.init(opts)       -> #{inspect opts}"
    [proxy: build_proxy(opts)]
  end

  def call(conn, opts) do
    Logger.debug "Main.call(conn, opts) -> #{inspect opts}"
    opts[:proxy].call(conn, [])
  end
end

With this setup, I can plug the main module in a Plug router:

plug DynamicPlugs.Main, foo: %{a: 1}, bar: %{b: 2}, baz: "ignored"

And then on the Plug server I get:

Compiling 19 files (.ex)

01:33:06.071 [debug] Main.init(opts)       -> [foo: %{a: 1}, bar: %{b: 2}, baz: "ignored"]

01:33:06.101 [debug] Bar.init(opts)        -> [foo: %{a: 1}, bar: %{b: 2}, baz: "ignored"]

01:33:06.102 [debug] Foo.init(opts)        -> [foo: %{a: 1}, bar: %{b: 2}, baz: "ignored"]
Generated XXXXX app

01:33:08.168 [debug] GET /

01:33:08.194 [debug] Main.call(conn, opts) -> [proxy: DynamicPlugs.Main.Proxy]

01:33:08.194 [debug] Foo.call(conn, opts)  -> %{a: 1}

01:33:08.194 [debug] Bar.call(conn, opts)  -> %{b: 2}

01:33:08.195 [debug] Sent 204 in 26ms

Post #9

bvobart

Thanks a lot for sharing your implementation! I was running into a similar problem while writing a small wrapper for a public plug and I was able to fix it with due to this topic and your solution!

I realize it’s been 7 years since this topic opened, but there is one important detail to add that can save future readers some problems and headaches: init/1 (and therefore the module-generating macro inside it) is evaluated at compile-time, meaning that in order to be able to use your wrapping plug in multiple places in your code, you must also incorporate a unique ID in your generated module’s name, otherwise you’ll just end up redefining the same module, overwriting its previous implementations, meaning only the latest compiled module will remain. That likely causes the wrong set of options to be used in most places where you’re using this plug. For me, it also caused some flakiness in my tests due to compilation race conditions.

Here’s what my solution incorporating such a unique ID looks like:

defmodule WrapperPlug do
  @behaviour Plug

  defmacrop build(opts, id) do
    # note: do not define `id` here, this line will only be executed once during compilation.
    # id = ...

    quote location: :keep do
      defmodule "Impl#{unquote(id)}" |> String.to_atom() do
        use Plug.Builder

        plug ChildPlug, unquote(opts)

        # ...
      end
    end
  end

  @impl Plug
  def init(opts) do
    # init is evaluated at compile-time, so a unique integer ID is used to ensure
    # that multiple instances of this plug can co-exist in one codebase.
    id = :erlang.unique_integer([:positive])
    {:module, mod, _, _} = build(opts, id)
    [mod: mod]
  end

  @impl Plug
  def call(conn, opts) do
    opts[:mod].call(conn, opts)
  end
end

Post #10

tompave

Yes, I get that, but so is the output of MainPlug.init/1, and I was hoping that there was some macro to store it in a module attribute and pass it down to the other plugs.
Looking into the code of Plug.Builder, however, I can see that the plug pipeline is “resolved and frozen” in __before_compile__, and I guess that the MainPlug module (or any module plug, really) is compiled before it gets referenced in the forward "/" ... call.

I can, but my child plugs are executed before MainPlug.call/2 is called, so it doesn’t really help me unless I manually invoke the plugs instead of relying on the plug macro.

Post #3