Here is a code example of what I mean. Let’s simulate a slow call (also printing a message every second while waiting):
defmodule Slow do
def call(seconds) do
for i <- (1..seconds) do
IO.puts("Waiting #{i}...")
Process.sleep(1_000)
end
end
end
Now create a GenServer setting a 3 seconds call timeout:
defmodule One do
def start_link(), do: GenServer.start_link(__MODULE__, [], [])
def hang(pid, seconds \\ 10),
do: GenServer.call(pid, {:hang, seconds}, 3000)
def init(_), do: {:ok, nil}
def handle_call({:hang, seconds}, _from, state) do
reply = Slow.call(seconds)
{:reply, reply, state}
end
end
If we call One.hang(pid), it will hang until the 3 seconds timeout elapses, then error. As we can see from the printed messages though, the slow operation is still going on, and further calls will just engulf the inbox more and more:
{:ok, pid} = One.start_link()
One.hang()
# Waiting 1...
# Waiting 2...
# Waiting 3...
# ** (exit) exited in: GenServer.call(#PID<0.165.0>, {:hang, 30}, 5000)
# ** (EXIT) time out
# (elixir) lib/gen_server.ex:1009: GenServer.call/3
# Waiting 4...
# Waiting 5...
One.hang()
# Waiting 6...
# Waiting 7...
# Waiting 8...
# ** (exit) exited in: GenServer.call(#PID<0.165.0>, {:hang, 30}, 5000)
# ** (EXIT) time out
# (elixir) lib/gen_server.ex:1009: GenServer.call/3
# Waiting 9...
# Waiting 10...
# Waiting 1...
# Waiting 2...
# Waiting 3...
The GenServer.call timeout is not really helping, as it only stops the caller, not the callee. What would work is to implement logic on the callee side to stop the slow operation and cleanup if a timeout elapses:
defmodule Two do
def start_link(), do: GenServer.start_link(__MODULE__, [], [])
def hang(pid, seconds \\ 10),
do: GenServer.call(pid, {:hang, seconds}, :infinity)
def init(_), do: {:ok, nil}
def handle_call({:hang, seconds}, from, state) do
task = Task.async(Slow, :call, [seconds])
case Task.yield(task, 3000) || Task.shutdown(task) do
{:ok, reply} -> {:reply, reply, state}
nil -> {:stop, :timeout, state}
end
end
end
In this case, the slow call is wrapped in a Task that is terminated when the 3 seconds timeout elapses:
Two.hang(pid)
# Waiting 1...
# Waiting 2...
# Waiting 3...
# 18:57:12.341 [error] GenServer #PID<0.165.0> terminating
# ** (stop) time out
# Last message (from #PID<0.104.0>): {:hang, 30}
# ...
# ** (EXIT from #PID<0.104.0>) shell process exited with reason: time out
No more "Waiting #..." messages are logged, confirming that the slow Task is terminated after the timeout elapses.
and can’t say how universally applicable such an approach is but I believe it’s a reasonable tradeoff.