Trap process crash which occurs in handle_call

Question

I have 2 GenServer modules - A and B. B monitors A and implements handle_info to receive :DOWN message when A crashes.

In my example code, B makes synchronous request (handle_call) to A. While processing the request, A crashes. B is supposed to receive :DOWN message but it doesn't. Why?

When I replaced handle_call with handle_cast, B received :DOWN message. Can you please tell me why handle_call doesn't work whereas handle_cast does?

This is the simple example code:

defmodule A do
  use GenServer

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

  def fun(fun_loving_person) do
    GenServer.call(fun_loving_person, :have_fun)
  end

  def init(:ok) do
    {:ok, %{}}
  end

  def handle_call(:have_fun, _from, state) do
    ######################### Raise an error to kill process :A
    raise "TooMuchFun"

    {:reply, :ok, state}
  end
end

defmodule B do
  use GenServer

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

  def spread_fun(fun_seeker) do
    GenServer.call(:B, {:spread_fun, fun_seeker})
  end

  def init(:ok) do
    {:ok, %{}}
  end

  def handle_call({:spread_fun, fun_seeker}, _from, state) do
    ######################### Monitor :A
    Process.monitor(Process.whereis(:A))

    result = A.fun(fun_seeker)
    {:reply, result, state}
  rescue
    _ -> IO.puts "Too much fun rescued"
    {:reply, :error, state}
  end

  ######################### Receive :DOWN message because I monitor :A
  def handle_info({:DOWN, _ref, :process, _pid, _reason}, state) do
    IO.puts "============== DOWN DOWN DOWN =============="
    {:noreply, state}
  end
end

try do
  {:ok, a} = A.start_link
  {:ok, _b} = B.start_link
  :ok = B.spread_fun(a)
rescue
  exception -> IO.puts "============= #{inspect exception, pretty: true}"
end

Answer 1

In my example code, B makes synchronous request (handle_call) to A. While processing the request, A crashes. B is supposed to receive :DOWN message but it doesn't. Why?

B does receive the :DOWN message when A crashes, but because you are still in the handler for the call to A, it won't have an opportunity to handle the :DOWN message until the handle_call callback completes. It won't ever complete though, because the call will fail with an exit, which will crash B as well.

When I replaced handle_call with handle_cast, B received :DOWN message. Can you please tell me why handle_call doesn't work whereas handle_cast does?

Calls are synchronous, casts are asynchronous, so in this case, the handle_call callback which casts to A completes, and B is then free to handle the :DOWN message. B doesn't crash because casts implicitly ignore any failure in attempting to send the message, it's "fire and forget".

It seems to me you are trying to deal with A crashing when calling to it, that is trivially done like so:

def handle_call({:spread_fun, fun_seeker}, _from, state) do
  ######################### Monitor :A
  Process.monitor(Process.whereis(:A))

  result = A.fun(fun_seeker)
  {:reply, result, state}
catch
  :exit, reason ->
    {:reply, {:error, reason}, state}
rescue
  _ -> 
   IO.puts "Too much fun rescued"
   {:reply, :error, state}
end

This will catch the exit which occurs when the remote process is not alive, dies, or times out. You can match on specific exit reasons, such as :noproc by specifying the reason in the catch clause which you want to protect against.

It's not clear to me that you need the monitor, I guess it depends on what you want to use it for, but in your given example I would say you don't.