Run TCP client in a background/non-blocking process


i am running a TCP client using gen_tcp inside a GenServer, which is called by DynamicSupervisor using Supervisor.start_client(). Whenever I call this method, the output (which is logged with IO.puts) is blocking the REPL. I start the application via iex -S mix. In the future, it is planned to execute some actions when a specific message is received via TCP, but that’s not implemented currently. However, I need to perform multiple TCP-clients at once and after calling Supervisor.start_client() once, the REPL is blocked and another TCP client cant be spawned.

How can I run this TCP-Client in a background/non-blocking process?

Thanks in advance.

Do not do the work in init/1. Init is supposed to return quickly. Instead use continuation. See GenServer — Elixir v1.11.4. Return {:ok, state, {:continue, continue}} in your init/1 callback and continue your setup / whatever other sort of blocking operation in handle_continue/2.


Yeah, without seeing your client code, it’s hard to say why it would be blocking. Even a long running init callback shouldn’t block indefinitely.

My guess would be that your making a blocking call from within your init callback.

1 Like

Hey, thanks for the answer.

So in general, in my GenServer implementation, inside init/1 i call :gen_tcp.connect, a couple of :gen_tcp.send for authentication and other stuff, and at the end :gen_tcp.recv which calls itself recursively to receive data all the time until the client is stopped, which is possible the reason why its blocking the repl.

Yes, you should never do any “heavy lifting” stuff in init/1, and for sure no infinite loops. You in general shouldn’t do any infinite loops in gen_server as there is already an internal loop for that and you should rely on messages instead.

Here’s an example of TCP Client I’ve been using lately, this uses active: :once and receives messages in handle_info, it also uses SSL instead of TCP, but the interfaces are the same, should be able to swap out :ssl for :gen_tcp pretty easily.

In addition it uses a Registry to publish the messages once they’ve been properly parsed.

One thing to note about receiving your messages, this one can receive multiple messages per handle_info, so the parser is actually recursive. If your messages are null terminated, or some other termination, you can set that when you connect to the tcp socket. Check out all the options when connecting. Erlang -- gen_tcp

If everything is done in init/1, then you don’t need a GenServer. Just spawn_link/3 it:, ie:

def start_link(args) do
    pid = :erlang.spawn_link(__MODULE__, :init, [args])
    {ok, pid}

def child_spec(args) do
    %{id: __MODULE__,
      start: {__MODULE__, :start_link, [args]},
      type: :worker}

Now you have a supervise-able worker process just like a GenServer, except everything is in init/1