I currently try to send a network connection to another distributed node. While doing that, the socket closes.

The socket is created via :gen_tcp.

I know this is a hard problem and also possibly incredibly hard to solve, I just figured it was a common task and expected an easy solution.

  @spec delegate_socket(socket :: :gen_tcp.socket()) :: nil
  defp delegate_socket(socket) do
    delegate_node = Pool.get_node

    IO.puts "Sending socket to delegate node #{delegate_node}"
    IO.puts "#{Node.ping delegate_node}"

    pid = Node.spawn(delegate_node, fn ->
      IO.puts "running on node"

      receive do
        socket ->
          Server.Tcp.Handler.handle(socket)
      end
    end)


    send pid, socket
    # :ok = :gen_tcp.controlling_process socket, pid
  end

The Handle Function:

defmodule Server.Tcp.Handler do
  def handle(socket) do
    IO.puts "got in loop"

    socket
    |> read_line()
    |> write_line(socket)

    handle socket
  end

  defp read_line(socket) do
    {:ok, data} = :gen_tcp.recv(socket, 0)
    data
  end

  defp write_line(data, socket) do
    :gen_tcp.send(socket, data)
  end
end

If that’s just impossible, which is very reasonable, I would now a workaround, but that could be very, very inefficient.
So how would the expert Elixir/Erlang programmer proceed here?

I can’t really imagine that someone would plug an Ngnix or Traefik in front of there Elixir to do the load balancing.