Converting strings to node-names & fully-qualified hostnames

I’m trying to simulate a network locally, by spawning nodes on different ports. The nodes find each other through udp-broadcasts

   def listen socket, port do
    local_msg = to_string(port)
    receive do
      {:udp, _socket, _address, port, ^local_msg} ->
        IO.inspect port
        IO.puts "localmsg"
        listen socket, port
      {:udp, _socket, address, remote_port, _msg} ->
        string_address = ip_to_string(address)
        IO.puts "new node added at port: #{port}"
        #"OrderHandler_" <> to_string(remote_port) <> "@" <> string_address |> String.to_atom |>
        "OrderHandler_" <> to_string(remote_port) <> "@localhost" |> String.to_atom |>

The node-ids follows this format: OrderHandler_@
However, when I convert the string to atom, I get :“OrderHandler_@”, which does not match with the nodes atom :OrderHandler_@

How do I solve this?

Also when using

Node.start :nodename@localhost

It responds with localhost being an illegal name. Are there any solutions to this?

Well. I don’t know whether I understood it correctly, but I can suggest you create a list of valid atoms and then get an atom from that list instead of converting to string and vice-versa.

Does that make sense?

[OrderHandler_@, :OrderHandler_@, :OrderHandler_@]

If you are thinking that the extra double quotes in :"OrderHandler_@" cause it to fail the match, that’s not the problem. The double quotes are just the way the atom is printed: atom literals have to use quotes when they contain something else than unicode letters, numbers, underscores, and a few other permitted characters.

Since the atom in your example contains dots, the atom literal is printed with quotes (:OrderHandler_@ is not a valid atom literal). The quotes are not part of the atom though, in fact :foo == :"foo", so that is not the reason for your problem.

The reason why the atom does not match is something else, not evident from the code you posted.

Also, not sure if that was your intention, but Node.start/3 does not “spawn a node”. It turns the current node from non-distributed to distributed and dynamically gives it a name. You very rarely need to call this function. Usually, you would start your nodes from the command line, specifying their name with --name or --sname.

1 Like

Thanks for the reply, this actually solved the fully-qualified hostname problem

Thanks, that clarifies some things, I though that Node.start would spawn a new node, but that must mean I’ve only converted my current node to be distributed using three different names.

I was able to solve the issue by initializing three iex-interfaces using a batch-script:

defmodule SupervisorsTest do
  use ExUnit.Case
  import TCP_Driver
  import Poller
  doctest Poller
  @tag timeout: :infinity
  @tcp_ip {10,0,0,68}

  def nodename port do
    String.to_atom("OrderHandler_" <> to_string(port) <> "@")
  test "Pinger" do

    #There is a bug with the first initialized node
    #which causes a connection error. initializing a dummy solved it.
    spawn fn -> Node.start :dummynode@localhost end

    port1 = to_string(Enum.random(3000..3500))
    port2 = to_string(Enum.random(3000..3500))
    port3 = to_string(Enum.random(3000..3500))

    spawn fn -> System.cmd("run.bat", [port1, port2, port3]) end

    spawn fn -> System.cmd("kill_elevator_servers.bat", []) end
    spawn fn -> System.cmd("kill_iex.bat", []) end
    spawn fn -> System.cmd("kill_cmd.bat", []) end

  def start_supervisors node, tcp_port do
    Node.spawn(node, fn -> Supervisors.init(%{address: {10,0,0,68},port: tcp_port}) end)


And some simple cmd-commands. Startup:

start iex --name "OrderHandler_%1@" -S mix
start iex --name "OrderHandler_%2@" -S mix
start iex --name "OrderHandler_%3@" -S mix

start ../SimElevatorServer.exe --port %1
start ../SimElevatorServer.exe --port %2
start ../SimElevatorServer.exe --port %3


Taskkill /F /IM cmd.exe

Taskkill /IM SimElevatorServer.exe

Taskkill /F /IM erl.exe

This feels like a nasty way of controlling my nodes for testing, but it floats my boat.