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!

3 Likes

The opts binding in your call is defined at compile-time, so not really easy to pass down.

But you could always load stuff into the :private key of the conn and access that down the line later. :slight_smile:

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.

1 Like

Not a bad thing to do, but why are those plugs being called ‘before’ yours? Sounds like the pipeline is in the wrong order. You could always make the init a macro and do stuff then like what you want. :slight_smile:

Well, they’re plug'd inside my main plug, so they’re executed, in order, before my main plug’s call/2 function is called. I forgot to mention that my main plug is a Plug.Router.

Oh, that sounds promising! Didn’t know I could do that.
If I understand correctly, you’re suggesting to do something like this (pseudocode):

defmodule MyPackage.MainPlug do
  defmacro init(opts) do
    quote do
      plug MyPackage.PlugA, unquote(opts) # possibly extract just some keys
      plug MyPackage.PlugB, unquote(opts)
      plug MyPackage.PlugC, unquote(opts)
    end
    # ... how can I return the opts though?
  end

  def call(conn, opts) do
  end
end

I’m just not sure about preserving the plug behaviour and contract though. Shouldn’t init/1 return some term to pass to call/2, later? Also, where would the plugs be plugged? In the phoenix router that calls forward?

Ohh, ‘inside’, that makes sense. ^.^

Init in a plug is called at ‘global’ scope. Your code as-is will not work, but you can dynamically generate an inline module that finalizes it and returns that so your call can return it’s call (which then would delegate to your actual call code).

It would not be too hard to write a library to wrap all that up either. :slight_smile:

Thank you, but I’m not sure I understand what you mean. Can you please provide an example?

Basically plug MyModule generates essentially (not really, but this gets the point across more simply) def do_plug(state), do: MyModule.call(state, unquote(MyModule.init([])). What you could do is generate a new location-sensitive module name dynamically generated, generate a proxy module that sets up the pipeline then pass the name of it back in the options, then call it inside your call to do the actual work.

Hard to give a good example currently, maybe if I get time later to actually write it out, poke me if so?

1 Like

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

3 Likes