Run TCP client in a background/non-blocking process

Do not do the work in init/1. Init is supposed to return quickly. Instead use continuation. See GenServer — Elixir v1.20.2. 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.

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. gen_tcp — OTP 29.0.2 (kernel 11.0.2)

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}
end

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

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