Rust Implementation of Erlang Distribution Protocol.
The distribution protocol is used to communicate with distributed erlang nodes.
Gets a node entry from EPMD: ```rust use erldist::epmd::{DEFAULTEPMD_PORT, EpmdClient};
// Connect to the local EPMD. let connection = TcpStream::connect(("localhost", DEFAULTEPMDPORT)).await?; let client = EpmdClient::new(connection);
// Get the information of a node. let nodename = "foo"; if let Some(node) = client.getnode(node_name).await? { println!("Found: {:?}", node); } else { println!("Not found"); } ```
Sends a message to an Erlang node: ```rust use erldist::LOWESTDISTRIBUTIONPROTOCOLVERSION; use erldist::node::{Creation, LocalNode}; use erldist::handshake::ClientSideHandshake; use erldist::term::{Atom, Pid}; use erldist::message::{channel, Message};
// Connect to a peer node. let peerhost = "localhost"; let peerport = 7483; // NOTE: Usually, port number is retrieved from EPMD. let connection = TcpStream::connect((peerhost, peerport)).await?;
// Local node information. let creation = Creation::random(); let local_node = LocalNode::new("foo@localhost".parse()?, creation);
// Do handshake. let mut handshake = ClientSideHandshake::new(connection, localnode.clone(), "cookie"); let _status = handshake.executesendname(LOWESTDISTRIBUTIONPROTOCOLVERSION).await?; let (connection, peernode) = handshake.executerest(true).await?;
// Create a channel. let capabilityflags = localnode.flags & peernode.flags; let (mut tx, _) = channel(connection, capabilityflags);
// Send a message. let frompid = Pid::new(localnode.name.tostring(), 0, 0, localnode.creation.get()); let toname = Atom::from("bar"); let msg = Message::regsend(frompid, toname, Atom::from("hello").into()); tx.send(msg).await?; ```
Example commands: - EPMD Client Example: epmdcli.rs - Client Node Example: sendmsg.rs - Server Node Example: recv_msg.rs