Supervisores y estructura de aplicaciones

Building Resilient Systems

Guardians of Processes

Your First Supervisor

defmodule MySupervisor do
  use Supervisor

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

  @impl true
  def init(_init_arg) do
    # No children yet, just the supervisor itself
    children = []
    Supervisor.init(children, strategy: :one_for_one)
  end
end

# --- Main execution part ---
# This simulates starting the supervisor and checking its status.
# In a real app, this would be part of an Application's start/2.
IO.puts("Attempting to start MySupervisor...")
{:ok, supervisor_pid} = MySupervisor.start_link([])
IO.puts("MySupervisor started with PID: #{inspect(supervisor_pid)}")

# Check if the supervisor process is alive
if Process.alive?(supervisor_pid) do
  IO.puts("Supervisor is alive!")
else
  IO.puts("Supervisor is NOT alive!")
end

Understanding Supervision Strategies

Adding Supervised Children

defmodule MyWorker do
  use GenServer

  def start_link(_opts) do
    GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
  end

  @impl true
  def init(:ok) do
    IO.puts("MyWorker started!")
    {:ok, %{}}
  end

  @impl true
  def handle_call(:crash, _from, state) do
    IO.puts("MyWorker is crashing!")
    exit(:bad_state) # Simulate a crash
    {:reply, :ok, state} # This line won't be reached
  end
end

defmodule MySupervisorWithWorker do
  use Supervisor

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

  @impl true
  def init(_init_arg) do
    children = [
      # Define our worker as a child process
      Supervisor.child_spec(MyWorker, id: MyWorker)
    ]
    Supervisor.init(children, strategy: :one_for_one)
  end
end

# --- Main execution part ---
IO.puts("Starting supervisor with worker...")
{:ok, supervisor_pid} = MySupervisorWithWorker.start_link([])
IO.puts("Supervisor PID: #{inspect(supervisor_pid)}")

# Get the worker's PID
worker_pid = Process.whereis(MyWorker)
IO.puts("Initial MyWorker PID: #{inspect(worker_pid)}")

if Process.alive?(worker_pid) do
  IO.puts("Worker is alive and supervised.")
else
  IO.puts("Worker did not start correctly.")
end

Fault Tolerance in Action

defmodule MyWorker do
  use GenServer

  def start_link(_opts) do
    GenServer.start_link(__MODULE__, :ok, name: __MODULE__)
  end

  @impl true
  def init(:ok) do
    IO.puts("MyWorker started!")
    {:ok, %{}}
  end

  @impl true
  def handle_call(:crash, _from, state) do
    IO.puts("MyWorker is crashing!")
    exit(:bad_state) # Simulate a crash
    {:reply, :ok, state} # This line won't be reached
  end

  def crash_it do
    GenServer.call(__MODULE__, :crash)
  end
end

defmodule MySupervisorWithWorker do
  use Supervisor

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

  @impl true
  def init(_init_arg) do
    children = [
      Supervisor.child_spec(MyWorker, id: MyWorker)
    ]
    Supervisor.init(children, strategy: :one_for_one)
  end
end

# --- Main execution part ---
IO.puts("Starting supervisor with worker...")
{:ok, _supervisor_pid} = MySupervisorWithWorker.start_link([])

worker_pid_before_crash = Process.whereis(MyWorker)
IO.puts("Worker PID before crash: #{inspect(worker_pid_before_crash)}")

# Crash the worker
IO.puts("Attempting to crash the worker...")
MyWorker.crash_it()
:timer.sleep(100) # Give supervisor a moment to restart

worker_pid_after_crash = Process.whereis(MyWorker)
IO.puts("Worker PID after crash: #{inspect(worker_pid_after_crash)}")

if worker_pid_before_crash != worker_pid_after_crash && Process.alive?(worker_pid_after_crash) do
  IO.puts("Worker was restarted by the supervisor! New PID detected.")
else
  IO.puts("Worker was NOT restarted, or PID remained the same (unexpected).")
end

Elixir Applications: The Top Level

The `Application` Behavior

defmodule MyApp.Application do
  use Application

  # This is the entry point for your application.
  # It starts the top-level supervisor.
  @impl true
  def start(_type, _args) do
    children = [
      # In a real app, you'd start your main supervisor here.
      # For example: Supervisor.child_spec(MySupervisorWithWorker, id: MySupervisorWithWorker)
    ]

    # Start a supervisor that will supervise other processes/supervisors
    opts = [strategy: :one_for_one, name: MyApp.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

# --- Main execution part ---
# This part simulates how an application would be started.
# In a real Mix project, 'mix run --no-halt' would call MyApp.Application.start/2
IO.puts("Simulating application start...")
{:ok, pid} = MyApp.Application.start(:normal, [])
IO.puts("Application top-level supervisor started with PID: #{inspect(pid)}")

if Process.alive?(pid) do
  IO.puts("Application supervisor is active.")
else
  IO.puts("Application supervisor failed to start.")
end

Hierarchical Supervision Trees

Supervisor Check

Lesson Summary