Alternative for Supervisor.Spec

Aetherus

I noticed that Spervisor.Spec is deprecated. The question is, what’s the alternative for Supervisor.Spec.worker and Spuervisor.Spec.supervisor that passes 0 or more than 1 arguments to the worker/supervisor module’s start_link?

For example, prior to Elixir 1.5, I can inline the name of an Agent so that I don’t have to define that module:

import Supervisor.Spec

children = [
  worker(Agent, [fn -> [] end, [name: MyAgent]])
]

Supervisor.start_link(children, strategy: :one_for_one)

How can I do this with the new Supervisor API since it requires to pass 2 arguments to Agent.start_link? What if I have a module whose start_link takes no arguments?

4 comments

#supervisor

1 4121 4

2018-01-12 07:48:48 UTC

Showing Posts 1 to 4

Show Best Posts
Show All (oldest first)
Show All (newest first)

gon782

You can see the new spec stuff here: https://hexdocs.pm/elixir/master/Supervisor.html

To summarize, your alternatives are either the map based specification for each child, which is exactly what an OTP supervisor actually receives behind the curtain, or module based supervisors. The map based child specs were added quite late to OTP which is why the workaround with better UX was added to Elixir:

  %{
    id: Stack,
    start: {Stack, :start_link, [[:hello]]},
    ...
  }

Module based supervisors where you can do:

defmodule MyApp.Supervisor do
  # Automatically defines child_spec/1
  use Supervisor

  def start_link(arg) do
    Supervisor.start_link(__MODULE__, arg, name: __MODULE__)
  end

  def init(_arg) do
    children = [
      {Stack, [:hello]}
    ]

    Supervisor.init(children, strategy: :one_for_one)
  end
end

Note that you can’t start a process by way of start_link/0 with the module based supervisor, because when you pass {Stack, []} or simply Stack it actually will pass [] to start_link. The map based child spec doesn’t have this issue, since you’d just pass start: {Stack, :start_link, []} to it and it’ll work just like every other place where you pass MFAs (Module, Function, Arguments) in Erlang.

Post #1

gon782

Just as a note, you can use both of the above in the same supervisor:

defmodule Downloader do
  use Application

  def start(_type, _args) do
    config_reader = %{
      id: Downloader.Config.Reader,
      start: {Downloader.Config.Reader, :start_link, []}
    }

    children = [
      Downloader.Download.Supervisor,
      Downloader.RSS.Reader.Supervisor,
      Downloader.Torrent.Filter,
      Downloader.Torrent.Store,
      config_reader,
      Downloader.RSS.Reader.Manager,
      Downloader.Notifier
    ]

    opts = [strategy: :one_for_one, name: Downloader.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

Post #2

Aetherus

Thanks a lot. I feel like an idiot for not reading the documentation carefully.

Post #3

gon782

I think Supervisor is one of those things that gets comparatively little scrutiny and checking up on as time passes in general, being that we can probably count the amount of times we need to sit down and write the specs for them on a couple of hands, if even that, in any given project. I’m guessing most people are used to them just being there.

The docs are generally fantastic, though, so do have a look when therë́s something you’re wondering about.

Post #4

— All posts loaded —