Just in case someone else (like me) happens upon this thread looking for guidance, but doesn’t quite grok what José is suggesting (also like me, initially):

I happened to find this great TIL repo by @slashdotdash that gives you a working example:

Thank you, everyone!

I also have a DynamicSupervisor which needs to start some children on app startup.

For that I used the module based DynamicSupervisor so I can hook into the init function like that:

  def init(_arg) do
    Manager.subject_server_startup()
    DynamicSupervisor.init(strategy: :one_for_one)
  end

My Manager is in itself a GenServer, here are some snippets from my code:

  def subject_server_startup() do
    GenServer.cast(__MODULE__, :subjects_supervisor_startup)
  end

  def handle_cast(:subjects_supervisor_startup, state) do
    for subject <- config() do
      start_subject(subject)
    end

    {:noreply, state}
  end

I think it’s because of the restart strategy of the Task module, here’s the documentation:

https://hexdocs.pm/elixir/1.12/Task.html#module-statically-supervised-tasks

Opposite to GenServer, Agent and Supervisor, a Task has a default :restart of :temporary . This means the task will not be restarted even if it crashes. If you desire the task to be restarted for non-successful exits, do:

You can simulate this by creating a Task module yourself,

defmodule MyTask do
  require Logger
  # use Task, restart: :transient
  use Task

  def start_link(arg) do
    Task.start_link(__MODULE__, :run, [arg])
  end

  def run(arg) do
    Logger.info("Hello")
  end
end

Then put in in your supervision tree like normal {MyTask, []}. Kill the first process and you’ll see that MyTask doesn’t restart, then now try with the restart: :transient flag, and you’ll see it works

I tried this but it doesn’t seem to work? It just restarts my DynamicSupervisor and not my Task.
Is it because the Task has already finished so it can’t be “restarted”?

My Supervisor looks like this:

defmodule MyApp.ControllerSupervisor do
  use Supervisor

  require Logger

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

  def init(_init_arg) do
    children = [
      {MyApp.DynamicControllerSupervisor, []},
      {Task,
       fn ->
         Logger.info("Task started")
         MyApp.DynamicControllerSupervisor.autostart_controller_connections
       end}
    ]

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

Ooh, that’s better than how I was doing this, thanks!

One interesting thing I realized while tinkering around with implementing support for this is that doing so makes the behaviour contract for DynamicSupervisor match that of Supervisor (by returning a list of children + options in init/1).

I agree this behaviour is not common and most apps don’t need such a feature, but it does provide a compelling ‘upgrade path’ from a Supervisor to DynamicSupervisor: just replace the module name in use Supervisor and Supervisor.init, with the knowledge that any callback returns crafted by hand (instead of Supervisor.init) will continue to work since both callbacks now accept the same shape.

Then you could begin converting a Supervisor to a DynamicSupervisor with the knowledge that any children you were relying upon to be started initially in your supervision tree still will be as you gradually refactor how they are launched.

Of course, this is solving a problem I don’t think exists, I just find the parity and parallels pretty—agreed it’s probably not worth complicating the implementation for.