aboutsummaryrefslogtreecommitdiffstats
path: root/gleam/gossip/src
diff options
context:
space:
mode:
Diffstat (limited to 'gleam/gossip/src')
-rw-r--r--gleam/gossip/src/client.gleam4
-rw-r--r--gleam/gossip/src/gossip.gleam111
-rw-r--r--gleam/gossip/src/p2p_peer.gleam37
-rw-r--r--gleam/gossip/src/registry.gleam298
-rw-r--r--gleam/gossip/src/validation.gleam95
5 files changed, 244 insertions, 301 deletions
diff --git a/gleam/gossip/src/client.gleam b/gleam/gossip/src/client.gleam
index ab1e368..33c86f7 100644
--- a/gleam/gossip/src/client.gleam
+++ b/gleam/gossip/src/client.gleam
@@ -31,8 +31,8 @@ fn loop(subject: process.Subject(messages.Message)) -> Nil {
let msg = process.receive_forever(subject)
case msg {
- messages.ChatMessage(from, text, _timestamp) -> {
- io.println("[" <> from <> "] " <> text)
+ messages.ChatMessage(from, text, timestamp) -> {
+ io.println("[" <> timestamp <> "] [" <> from <> "] " <> text)
loop(subject)
}
messages.UserJoinMessage(name) -> {
diff --git a/gleam/gossip/src/gossip.gleam b/gleam/gossip/src/gossip.gleam
index e40e48c..ce275de 100644
--- a/gleam/gossip/src/gossip.gleam
+++ b/gleam/gossip/src/gossip.gleam
@@ -1,9 +1,9 @@
import gleam/erlang/charlist
import gleam/io
-import gleam/list
import gleam/option.{None, Some}
import gleam/string
import p2p_peer
+import validation
/// Main entry point for interactive mode.
///
@@ -93,7 +93,7 @@ pub fn main_with_args(peer_name: String, bootstrap_peer: String) -> Nil {
/// 5. If bootstrap peer provided, connect to them
/// 6. Start input loop to read user messages
fn run_peer(name: String, remote_name: option.Option(String)) -> Nil {
- let validated_name = validate_peer_name(name)
+ let validated_name = validation.validate_peer_name(name)
case validated_name {
Error(msg) -> {
@@ -102,7 +102,7 @@ fn run_peer(name: String, remote_name: option.Option(String)) -> Nil {
Ok(clean_name) -> {
// Validate remote name if provided
let remote_validation = case remote_name {
- Some(remote) -> validate_remote_peer(remote)
+ Some(remote) -> validation.validate_remote_peer(remote)
None -> Ok(Nil)
}
@@ -113,7 +113,7 @@ fn run_peer(name: String, remote_name: option.Option(String)) -> Nil {
Ok(Nil) -> {
// Generate registry_id from peer name hash to ensure uniqueness
// Uses string length + char codes to reduce collisions (much better than just length)
- let registry_id = hash_peer_name(clean_name)
+ let registry_id = validation.hash_peer_name(clean_name)
// Start the peer (creates client and registry actors)
let #(_client_subject, registry_subject) =
@@ -141,109 +141,6 @@ fn run_peer(name: String, remote_name: option.Option(String)) -> Nil {
}
}
-/// Validate a peer name.
-///
-/// Requirements:
-/// - Non-empty after trimming whitespace
-/// - At least 1 character, at most 32 characters
-/// - Must be a valid identifier (alphanumeric + underscore)
-fn validate_peer_name(name: String) -> Result(String, String) {
- let trimmed = string.trim(name)
-
- case string.length(trimmed) {
- 0 -> Error("Peer name cannot be empty")
- len if len > 32 -> Error("Peer name too long (max 32 characters)")
- _ -> {
- // Check for valid characters: alphanumeric and underscore
- case is_valid_identifier(trimmed) {
- True -> Ok(trimmed)
- False ->
- Error("Peer name must contain only letters, numbers, and underscores")
- }
- }
- }
-}
-
-/// Validate a remote peer address.
-///
-/// Accepts:
-/// - Peer name: "alice" (alphanumeric)
-/// - Node address: "alice@localhost" or "alice@192.168.1.1"
-fn validate_remote_peer(remote: String) -> Result(Nil, String) {
- let trimmed = string.trim(remote)
-
- case string.length(trimmed) {
- 0 -> Error("Remote peer address cannot be empty")
- len if len > 256 -> Error("Remote peer address too long")
- _ -> {
- // Check if it's a node address (contains @) or just a peer name
- case string.contains(trimmed, "@") {
- True -> {
- // Node address format: peer_name@hostname
- // Basic validation: should have exactly one @
- let parts = string.split(trimmed, "@")
- case list.length(parts) {
- 2 -> {
- let peer_part = case parts {
- [p, _] -> p
- _ -> ""
- }
- case is_valid_identifier(peer_part) {
- True -> Ok(Nil)
- False -> Error("Invalid peer name in address: " <> peer_part)
- }
- }
- _ -> Error("Invalid node address format (expected: peer@hostname)")
- }
- }
- False -> {
- // Just a peer name
- case is_valid_identifier(trimmed) {
- True -> Ok(Nil)
- False ->
- Error("Invalid peer name (must be alphanumeric + underscore)")
- }
- }
- }
- }
- }
-}
-
-/// Check if a string is a valid identifier.
-/// Valid: alphanumeric (a-z, A-Z, 0-9) and underscore
-fn is_valid_identifier(s: String) -> Bool {
- let chars = string.split(s, "")
- list.all(chars, fn(c) {
- let is_alpha =
- string.contains("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", c)
- let is_digit = string.contains("0123456789", c)
- let is_underscore = c == "_"
- is_alpha || is_digit || is_underscore
- })
-}
-
-/// Generate a unique registry ID from a peer name.
-///
-/// Uses string length combined with sum of character codes (via Erlang binary_to_list).
-/// This provides much better collision resistance than length alone.
-/// Examples:
-/// - "alice" (5) + (97+108+105+99+101) = 5 + 510 = 515
-/// - "bob" (3) + (98+111+98) = 3 + 307 = 310
-/// - "carol" (5) + (99+97+114+111+108) = 5 + 529 = 534
-///
-/// Collisions are still theoretically possible but extremely unlikely
-/// for names used in small networks (< 1000 peers).
-fn hash_peer_name(name: String) -> Int {
- let len = string.length(name)
- let char_sum = sum_char_codes(name)
- len * 100 + char_sum
-}
-
-/// Sum the character codes of all characters in a string.
-/// Uses Erlang's binary_to_list to convert string to character codes, then sums them.
-@external(erlang, "gossip_utils", "sum_char_codes")
-fn sum_char_codes(str: String) -> Int
-
/// Read a line from stdin with a prompt.
///
/// Uses Erlang's io:get_line which returns a charlist.
diff --git a/gleam/gossip/src/p2p_peer.gleam b/gleam/gossip/src/p2p_peer.gleam
index 08234fb..b10a884 100644
--- a/gleam/gossip/src/p2p_peer.gleam
+++ b/gleam/gossip/src/p2p_peer.gleam
@@ -26,22 +26,9 @@ pub fn start(
}
io.println("")
- io.println("Ready to receive messages as: " <> name)
- io.println("")
- io.println("To connect from another peer, tell them to run:")
- io.println("")
- io.println("Same machine:")
- io.println(" gossip <their-name> " <> full_node_address)
- io.println("")
- io.println("Different machine (replace with actual hostname/IP):")
- io.println(
- " gossip <their-name> " <> name <> "@<your-machine-hostname-or-ip>",
- )
- io.println("")
- io.println(
- "Note: For cross-machine connections, the bootstrap peer must use --network flag:",
- )
- io.println(" gossip " <> name <> " --network")
+ io.println("Ready as: " <> name <> " (" <> full_node_address <> ")")
+ io.println("Others connect with: gossip <name> " <> full_node_address)
+ io.println("Type /help for commands.")
io.println("")
#(client_subject, registry_subject)
@@ -210,10 +197,16 @@ pub fn input_loop(
input_loop(registry_subject, name, registry_id)
}
"/list" -> {
- // List connected peers
process.send(registry_subject, messages.ListPeers(0))
input_loop(registry_subject, name, registry_id)
}
+ "/help" | "/?" -> {
+ io.println("Commands:")
+ io.println(" /list — show connected peers")
+ io.println(" /help — show this message")
+ io.println(" /quit — leave the network")
+ input_loop(registry_subject, name, registry_id)
+ }
"/quit" | "/leave" -> {
// User explicitly quit - notify peers and exit
process.send(
@@ -225,19 +218,13 @@ pub fn input_loop(
exit_vm()
}
_ -> {
- // Get current timestamp
let timestamp = get_timestamp()
-
- // Send message to registry with:
- // - origin_id = our registry_id (so other peers know it's from us)
- // - last_sender_id = -1 (local input, not forwarded from peers)
- // - timestamp = current time
- // - is_local = True (indicates this came from local input)
+ // Echo own message locally (terminal echo is suppressed during input)
+ io.println("[" <> timestamp <> "] [" <> name <> "] " <> trimmed)
process.send(
registry_subject,
messages.Broadcast(name, trimmed, registry_id, -1, timestamp, True),
)
-
input_loop(registry_subject, name, registry_id)
}
}
diff --git a/gleam/gossip/src/registry.gleam b/gleam/gossip/src/registry.gleam
index c89fd1f..713dd47 100644
--- a/gleam/gossip/src/registry.gleam
+++ b/gleam/gossip/src/registry.gleam
@@ -2,18 +2,18 @@ import gleam/erlang/process
import gleam/list
import gleam/int
import gleam/io
-import gleam/string
import messages
/// Peer information including health status for liveness detection.
-///
-/// Structure: #(peer_name, registry_id, registry_subject, last_heartbeat_time, consecutive_failures)
-/// - peer_name: the peer's name
-/// - registry_id: unique identifier for loop prevention
-/// - registry_subject: Subject to send messages to this peer
-/// - last_heartbeat_time: Unix timestamp of last successful heartbeat response
-/// - consecutive_failures: number of consecutive failed heartbeat pings (resets on success)
-type Peer = #(String, Int, process.Subject(messages.Message), Int, Int)
+type Peer {
+ Peer(
+ name: String,
+ registry_id: Int,
+ registry_subject: process.Subject(messages.Message),
+ last_heartbeat_time: Int,
+ consecutive_failures: Int,
+ )
+}
// === Heartbeat Configuration ===
// Timeout for receiving messages in the main loop (milliseconds)
@@ -31,42 +31,14 @@ const peer_unresponsive_threshold_s = 120
// This allows time for network issues, peer reconnection, etc.
const peer_failure_threshold = 3
-// === Peer Accessor Functions ===
-// Extract peer fields for better readability and DRY code
-
-/// Get the peer's name
-fn peer_name(peer: Peer) -> String {
- peer.0
-}
-
-/// Get the peer's registry ID
-fn peer_registry_id(peer: Peer) -> Int {
- peer.1
-}
-
-/// Get the peer's registry subject
-fn peer_registry(peer: Peer) -> process.Subject(messages.Message) {
- peer.2
-}
-
-/// Get the last heartbeat timestamp
-fn peer_last_heartbeat(peer: Peer) -> Int {
- peer.3
-}
-
-/// Get the consecutive failures count
-fn peer_failures(peer: Peer) -> Int {
- peer.4
-}
-
/// Create a new peer with updated health status
fn peer_with_health(peer: Peer, last_heartbeat_time: Int, failures: Int) -> Peer {
- #(peer_name(peer), peer_registry_id(peer), peer_registry(peer), last_heartbeat_time, failures)
+ Peer(..peer, last_heartbeat_time: last_heartbeat_time, consecutive_failures: failures)
}
/// Check if a peer is considered healthy (not yet failed too many times)
fn peer_is_healthy(peer: Peer) -> Bool {
- peer_failures(peer) < peer_failure_threshold
+ peer.consecutive_failures < peer_failure_threshold
}
/// Registry state: all information a peer's registry maintains.
@@ -75,9 +47,7 @@ fn peer_is_healthy(peer: Peer) -> Bool {
/// - clients: always contains at least our local client
/// - peers: list of other peer registries we're connected to
/// - registry_id: uniquely identifies this registry for loop prevention
-///
-/// Note: Message deduplication is tracked in the process dictionary (not in state)
-/// because state updates don't persist across loop iterations reliably.
+/// - seen_messages: bounded dedup store, capped at 1000 entries
type RegistryState {
RegistryState(
clients: List(#(String, process.Subject(messages.Message))),
@@ -85,6 +55,7 @@ type RegistryState {
local_client: process.Subject(messages.Message),
local_name: String,
registry_id: Int,
+ seen_messages: List(#(Int, String, String, String)),
)
}
@@ -104,6 +75,7 @@ pub fn start(client_subject: process.Subject(messages.Message), name: String, re
local_client: client_subject,
local_name: name,
registry_id: registry_id,
+ seen_messages: [],
)
// Create a channel to communicate the subject back
@@ -117,9 +89,6 @@ pub fn start(client_subject: process.Subject(messages.Message), name: String, re
// Send the subject back so the caller can use it
process.send(channel, registry_subject)
- // Initialize the process dictionary to track seen messages
- let _ = init_seen_messages_store()
-
// Start the loop
loop(registry_subject, initial_state)
})
@@ -140,35 +109,22 @@ pub fn start(client_subject: process.Subject(messages.Message), name: String, re
registry_subject
}
-/// Initialize the seen messages store in process dictionary
-fn init_seen_messages_store() -> Nil {
- erl_put("seen_broadcast_ids", [])
-}
-
/// Check if we've seen this message before
-fn has_seen_message(message_id: #(Int, String, String, String)) -> Bool {
- let seen = erl_get("seen_broadcast_ids")
- list.contains(seen, message_id)
+fn has_seen_message(message_id: #(Int, String, String, String), state: RegistryState) -> Bool {
+ list.contains(state.seen_messages, message_id)
}
-/// Mark a message as seen
-fn mark_message_seen(message_id: #(Int, String, String, String)) -> Nil {
- let seen = erl_get("seen_broadcast_ids")
- let new_seen = [message_id, ..seen]
+/// Mark a message as seen; returns updated state
+fn mark_message_seen(message_id: #(Int, String, String, String), state: RegistryState) -> RegistryState {
+ let new_seen = [message_id, ..state.seen_messages]
// Keep bounded to prevent memory leak
let trimmed = case list.length(new_seen) > 1000 {
True -> list.take(new_seen, 900)
False -> new_seen
}
- erl_put("seen_broadcast_ids", trimmed)
+ RegistryState(..state, seen_messages: trimmed)
}
-@external(erlang, "erlang", "put")
-fn erl_put(key: String, value: a) -> Nil
-
-@external(erlang, "erlang", "get")
-fn erl_get(key: String) -> a
-
/// Check peer health and send heartbeat ping if needed.
///
/// Logic:
@@ -177,16 +133,16 @@ fn erl_get(key: String) -> a
///
/// Returns updated peer tuple with new failure count
fn check_and_ping_peer(peer: Peer, current_time: Int, local_name: String, local_registry_id: Int) -> Peer {
- let time_since_last_heartbeat = current_time - peer_last_heartbeat(peer)
-
+ let time_since_last_heartbeat = current_time - peer.last_heartbeat_time
+
case time_since_last_heartbeat > peer_unresponsive_threshold_s {
True -> {
// Peer unresponsive: increment failure counter
- peer_with_health(peer, peer_last_heartbeat(peer), peer_failures(peer) + 1)
+ peer_with_health(peer, peer.last_heartbeat_time, peer.consecutive_failures + 1)
}
False -> {
// Peer appears healthy: send a heartbeat ping
- let _ = erlang_send(peer_registry(peer), messages.Heartbeat(local_name, local_registry_id))
+ let _ = erlang_send(peer.registry_subject, messages.Heartbeat(local_name, local_registry_id))
peer
}
}
@@ -247,80 +203,91 @@ fn loop(subject: process.Subject(messages.Message), state: RegistryState) -> Nil
let msg = erlang_receive_with_timeout(heartbeat_check_interval_ms)
case msg {
- messages.PeerJoin(peer_name, peer_registry_id) -> {
+ messages.PeerJoin(joining_name, joining_registry_id) -> {
// Peer handshake: add them to our peer list
- let peer_registry = whereis_global_subject(peer_name)
- case is_valid_subject(peer_registry) {
+ let peer_subj = whereis_global_subject(joining_name)
+ case is_valid_subject(peer_subj) {
True -> {
let current_time = get_unix_timestamp()
- let new_peer: Peer = #(peer_name, peer_registry_id, peer_registry, current_time, 0)
+ let new_peer = Peer(
+ name: joining_name,
+ registry_id: joining_registry_id,
+ registry_subject: peer_subj,
+ last_heartbeat_time: current_time,
+ consecutive_failures: 0,
+ )
let new_peers = list.append(state.peers, [new_peer])
let new_state = RegistryState(..state, peers: new_peers)
-
- // Send back acknowledgement (they'll look us up in global registry)
- let _ = erlang_send(peer_registry, messages.PeerAck(state.local_name, state.registry_id))
-
- // Display peer join to local client
- let _ = process.send(state.local_client, messages.UserJoinMessage(peer_name))
-
- // Send updated peer list to the new peer
- let peer_names = list.map(new_state.peers, fn(p) { p.0 })
- let _ = erlang_send(peer_registry, messages.RegistrySnapshot(peer_names))
-
- // Propagate join message to other peers
- let _ = list.each(state.peers, fn(p) {
- erlang_send(p.2, messages.UserJoinMessage(peer_name))
- })
-
- loop(subject, new_state)
+
+ // Send back acknowledgement (they'll look us up in global registry)
+ let _ = erlang_send(peer_subj, messages.PeerAck(state.local_name, state.registry_id))
+
+ // Display peer join to local client
+ let _ = process.send(state.local_client, messages.UserJoinMessage(joining_name))
+
+ // Send updated peer list to the new peer
+ let peer_names = list.map(new_state.peers, fn(p) { p.name })
+ let _ = erlang_send(peer_subj, messages.RegistrySnapshot(peer_names))
+
+ // Propagate join message to other peers
+ let _ = list.each(state.peers, fn(p) {
+ erlang_send(p.registry_subject, messages.UserJoinMessage(joining_name))
+ })
+
+ loop(subject, new_state)
}
False -> loop(subject, state)
}
}
- messages.PeerAck(peer_name, peer_registry_id) -> {
+ messages.PeerAck(acking_name, acking_registry_id) -> {
// Peer handshake response: look them up in global registry and add to our peer list
- let already_connected = list.any(state.peers, fn(p) { p.0 == peer_name })
+ let already_connected = list.any(state.peers, fn(p) { p.name == acking_name })
case already_connected {
True -> loop(subject, state)
False -> {
// Look up the responding peer's registry in the global registry
- let peer_registry = whereis_global_subject(peer_name)
- case is_valid_subject(peer_registry) {
+ let peer_subj = whereis_global_subject(acking_name)
+ case is_valid_subject(peer_subj) {
True -> {
let current_time = get_unix_timestamp()
- let new_peer: Peer = #(peer_name, peer_registry_id, peer_registry, current_time, 0)
+ let new_peer = Peer(
+ name: acking_name,
+ registry_id: acking_registry_id,
+ registry_subject: peer_subj,
+ last_heartbeat_time: current_time,
+ consecutive_failures: 0,
+ )
let new_peers = list.append(state.peers, [new_peer])
let new_state = RegistryState(..state, peers: new_peers)
-
- // Send current network state to the new peer via gossip
- let client_names = list.map(state.clients, fn(c) { c.0 })
- let peer_info = list.map(new_state.peers, fn(p) { #(p.0, p.1) })
- let _ = erlang_send(peer_registry, messages.Gossip(client_names, peer_info))
-
- // Display peer join to local client
- let _ = process.send(state.local_client, messages.UserJoinMessage(peer_name))
-
- // Send updated peer list to the new peer
- let peer_names = list.map(new_state.peers, fn(p) { p.0 })
- let _ = erlang_send(peer_registry, messages.RegistrySnapshot(peer_names))
-
- // Propagate join message to other peers
- let _ = list.each(state.peers, fn(p) {
- erlang_send(p.2, messages.UserJoinMessage(peer_name))
- })
-
- loop(subject, new_state)
+
+ // Send current network state to the new peer via gossip
+ let client_names = list.map(state.clients, fn(c) { c.0 })
+ let peer_info = list.map(new_state.peers, fn(p) { #(p.name, p.registry_id) })
+ let _ = erlang_send(peer_subj, messages.Gossip(client_names, peer_info))
+
+ // Display peer join to local client
+ let _ = process.send(state.local_client, messages.UserJoinMessage(acking_name))
+
+ // Send updated peer list to the new peer
+ let peer_names = list.map(new_state.peers, fn(p) { p.name })
+ let _ = erlang_send(peer_subj, messages.RegistrySnapshot(peer_names))
+
+ // Propagate join message to other peers
+ let _ = list.each(state.peers, fn(p) {
+ erlang_send(p.registry_subject, messages.UserJoinMessage(acking_name))
+ })
+
+ loop(subject, new_state)
}
False -> {
// Peer not found in global registry yet, skip for now
- // They will eventually gossip to us with their info
loop(subject, state)
}
}
}
}
- }
+ }
messages.ClientJoin(name, client_subject, origin_id) -> {
// Client joined: add if new, propagate to other peers
@@ -334,12 +301,12 @@ fn loop(subject: process.Subject(messages.Message), state: RegistryState) -> Nil
case state.registry_id == origin_id {
True -> {
// Send registry snapshot to the joining client
- let peer_names = list.map(state.peers, fn(p) { p.0 })
+ let peer_names = list.map(state.peers, fn(p) { p.name })
let _ = process.send(state.local_client, messages.RegistrySnapshot(peer_names))
-
+
// Broadcast join message to all peers
let _ = list.each(state.peers, fn(peer) {
- erlang_send(peer.2, messages.UserJoinMessage(name))
+ erlang_send(peer.registry_subject, messages.UserJoinMessage(name))
})
Nil
}
@@ -364,7 +331,7 @@ fn loop(subject: process.Subject(messages.Message), state: RegistryState) -> Nil
// Broadcast to all peers - send ClientLeave so they can propagate it
let _ = list.each(state.peers, fn(peer) {
- erlang_send(peer.2, messages.ClientLeave(client_name, origin_id, state.registry_id))
+ erlang_send(peer.registry_subject, messages.ClientLeave(client_name, origin_id, state.registry_id))
})
Nil
}
@@ -374,9 +341,9 @@ fn loop(subject: process.Subject(messages.Message), state: RegistryState) -> Nil
// Forward leave message to other peers (not back to the peer that sent it)
let _ = list.each(state.peers, fn(peer) {
- case peer.1 == last_sender_id {
+ case peer.registry_id == last_sender_id {
True -> Nil // Don't send back to the peer that relayed this to us
- False -> erlang_send(peer.2, messages.ClientLeave(client_name, origin_id, state.registry_id))
+ False -> erlang_send(peer.registry_subject, messages.ClientLeave(client_name, origin_id, state.registry_id))
}
})
Nil
@@ -387,7 +354,7 @@ fn loop(subject: process.Subject(messages.Message), state: RegistryState) -> Nil
messages.Broadcast(from, text, origin_id, last_sender_id, timestamp, is_local) -> {
// Broadcast message: display and forward
- //
+ //
// Message Display Strategy:
// - is_local=True: DON'T display (user already sees terminal echo)
// - is_local=False: Display (message from another peer, not yet visible)
@@ -395,10 +362,10 @@ fn loop(subject: process.Subject(messages.Message), state: RegistryState) -> Nil
// Message deduplication: Track ALL messages (local and network) to prevent
// duplicates when messages bounce back through mesh networks.
// Use (origin_id, from, text, timestamp) as unique identifier.
-
+
let message_id = #(origin_id, from, text, timestamp)
- let already_seen = has_seen_message(message_id)
-
+ let already_seen = has_seen_message(message_id, state)
+
// Only display messages from OTHER peers (not local input)
case !already_seen && !is_local {
True -> {
@@ -407,26 +374,26 @@ fn loop(subject: process.Subject(messages.Message), state: RegistryState) -> Nil
}
False -> Nil
}
-
+
// Mark as seen regardless of origin
// Local messages are tracked so bouncebacks don't display again
- let _ = mark_message_seen(message_id)
-
- case state.peers {
- [] -> Nil
- _peers -> {
- // Filter out the peer that sent this to us (identified by last_sender_id)
- let peers_to_forward = list.filter(state.peers, fn(peer) {
- peer.1 != last_sender_id
- })
-
- // Forward with our registry_id as last_sender_id so peers know not to echo back
- // Set is_local=False since we're forwarding from a peer
- propagate_broadcasts(peers_to_forward, messages.Broadcast(from, text, origin_id, state.registry_id, timestamp, False))
- }
- }
- loop(subject, state)
- }
+ let new_state = mark_message_seen(message_id, state)
+
+ case new_state.peers {
+ [] -> Nil
+ _peers -> {
+ // Filter out the peer that sent this to us (identified by last_sender_id)
+ let peers_to_forward = list.filter(new_state.peers, fn(peer) {
+ peer.registry_id != last_sender_id
+ })
+
+ // Forward with our registry_id as last_sender_id so peers know not to echo back
+ // Set is_local=False since we're forwarding from a peer
+ propagate_broadcasts(peers_to_forward, messages.Broadcast(from, text, origin_id, new_state.registry_id, timestamp, False))
+ }
+ }
+ loop(subject, new_state)
+ }
messages.Gossip(_peer_client_names, peer_info) -> {
// Gossip: learn about clients and peers from remote registries
@@ -437,7 +404,7 @@ fn loop(subject: process.Subject(messages.Message), state: RegistryState) -> Nil
let new_state = RegistryState(..state, peers: new_peers)
// Display updated peer list to local client
- let peer_names = list.map(new_state.peers, fn(p) { p.0 })
+ let peer_names = list.map(new_state.peers, fn(p) { p.name })
let _ = process.send(state.local_client, messages.RegistrySnapshot(peer_names))
loop(subject, new_state)
@@ -446,9 +413,9 @@ fn loop(subject: process.Subject(messages.Message), state: RegistryState) -> Nil
messages.Heartbeat(sender_name, sender_registry_id) -> {
// Heartbeat ping from another peer: respond immediately
// Get the registry of the sender from our peer list
- case list.find(state.peers, fn(p) { peer_name(p) == sender_name && peer_registry_id(p) == sender_registry_id }) {
+ case list.find(state.peers, fn(p) { p.name == sender_name && p.registry_id == sender_registry_id }) {
Ok(peer) -> {
- let peer_reg = peer_registry(peer)
+ let peer_reg = peer.registry_subject
// Send HeartbeatAck back to the sender
let _ = erlang_send(peer_reg, messages.HeartbeatAck(state.local_name, state.registry_id))
loop(subject, state)
@@ -464,7 +431,7 @@ fn loop(subject: process.Subject(messages.Message), state: RegistryState) -> Nil
// Heartbeat acknowledgement: reset peer's health status
let current_time = get_unix_timestamp()
let updated_peers = list.map(state.peers, fn(peer) {
- case peer_name(peer) == sender_name {
+ case peer.name == sender_name {
True -> peer_with_health(peer, current_time, 0) // Successful response: reset failures
False -> peer
}
@@ -475,7 +442,7 @@ fn loop(subject: process.Subject(messages.Message), state: RegistryState) -> Nil
messages.ListPeers(_) -> {
// User requested to see list of connected peers
- let peer_names = list.map(state.peers, fn(p) { p.0 })
+ let peer_names = list.map(state.peers, fn(p) { p.name })
let _ = process.send(state.local_client, messages.RegistrySnapshot(peer_names))
loop(subject, state)
}
@@ -519,11 +486,7 @@ fn loop(subject: process.Subject(messages.Message), state: RegistryState) -> Nil
/// to reach peer registries across the network.
fn propagate(peers: List(Peer), msg: messages.Message) -> Nil {
list.each(peers, fn(peer) {
- let _name = peer.0
- let _peer_id = peer.1
- let registry_subject = peer.2
- // Use erlang_send since these are raw Pids, not proper Gleam Subjects
- let _ = erlang_send(registry_subject, msg)
+ let _ = erlang_send(peer.registry_subject, msg)
Nil
})
}
@@ -534,11 +497,7 @@ fn propagate(peers: List(Peer), msg: messages.Message) -> Nil {
/// Uses raw Erlang ! operator to reach peer registries across the network.
fn propagate_broadcasts(peers: List(Peer), msg: messages.Message) -> Nil {
list.each(peers, fn(peer) {
- let _name = peer.0
- let _peer_id = peer.1
- let registry_subject = peer.2
- // Use erlang_send since these are raw Pids, not proper Gleam Subjects
- let _ = erlang_send(registry_subject, msg)
+ let _ = erlang_send(peer.registry_subject, msg)
Nil
})
}
@@ -613,22 +572,27 @@ fn auto_discover_peers(
True -> peers
False -> {
// Check if we already know this peer
- let already_known = list.any(peers, fn(p) { p.0 == peer_name })
+ let already_known = list.any(peers, fn(p) { p.name == peer_name })
case already_known {
True -> peers
False -> {
// Try to look up and connect to this peer
- let peer_registry = whereis_global_subject(peer_name)
- case is_valid_subject(peer_registry) {
- True -> {
- // Found the peer, add them to our peer list
- let current_time = get_unix_timestamp()
- let new_peer: Peer = #(peer_name, peer_registry_id, peer_registry, current_time, 0)
- list.append(peers, [new_peer])
+ let peer_subj = whereis_global_subject(peer_name)
+ case is_valid_subject(peer_subj) {
+ True -> {
+ // Found the peer, add them to our peer list
+ let current_time = get_unix_timestamp()
+ let new_peer = Peer(
+ name: peer_name,
+ registry_id: peer_registry_id,
+ registry_subject: peer_subj,
+ last_heartbeat_time: current_time,
+ consecutive_failures: 0,
+ )
+ list.append(peers, [new_peer])
}
False -> {
// Peer not found locally or on connected nodes, skip for now
- // They may become available later
peers
}
}
diff --git a/gleam/gossip/src/validation.gleam b/gleam/gossip/src/validation.gleam
new file mode 100644
index 0000000..361f1d8
--- /dev/null
+++ b/gleam/gossip/src/validation.gleam
@@ -0,0 +1,95 @@
+import gleam/list
+import gleam/string
+
+/// Validate a peer name.
+///
+/// Requirements:
+/// - Non-empty after trimming whitespace
+/// - At least 1 character, at most 32 characters
+/// - Must be a valid identifier (alphanumeric + underscore)
+pub fn validate_peer_name(name: String) -> Result(String, String) {
+ let trimmed = string.trim(name)
+
+ case string.length(trimmed) {
+ 0 -> Error("Peer name cannot be empty")
+ len if len > 32 -> Error("Peer name too long (max 32 characters)")
+ _ -> {
+ case is_valid_identifier(trimmed) {
+ True -> Ok(trimmed)
+ False ->
+ Error("Peer name must contain only letters, numbers, and underscores")
+ }
+ }
+ }
+}
+
+/// Validate a remote peer address.
+///
+/// Accepts:
+/// - Peer name: "alice" (alphanumeric)
+/// - Node address: "alice@localhost" or "alice@192.168.1.1"
+pub fn validate_remote_peer(remote: String) -> Result(Nil, String) {
+ let trimmed = string.trim(remote)
+
+ case string.length(trimmed) {
+ 0 -> Error("Remote peer address cannot be empty")
+ len if len > 256 -> Error("Remote peer address too long")
+ _ -> {
+ case string.contains(trimmed, "@") {
+ True -> {
+ let parts = string.split(trimmed, "@")
+ case list.length(parts) {
+ 2 -> {
+ let peer_part = case parts {
+ [p, _] -> p
+ _ -> ""
+ }
+ case is_valid_identifier(peer_part) {
+ True -> Ok(Nil)
+ False -> Error("Invalid peer name in address: " <> peer_part)
+ }
+ }
+ _ -> Error("Invalid node address format (expected: peer@hostname)")
+ }
+ }
+ False -> {
+ case is_valid_identifier(trimmed) {
+ True -> Ok(Nil)
+ False ->
+ Error("Invalid peer name (must be alphanumeric + underscore)")
+ }
+ }
+ }
+ }
+ }
+}
+
+/// Check if a string is a valid identifier.
+/// Valid: alphanumeric (a-z, A-Z, 0-9) and underscore.
+/// Note: empty string returns True (vacuous truth from list.all).
+/// Callers that care about empty should check length separately.
+pub fn is_valid_identifier(s: String) -> Bool {
+ let chars = string.split(s, "")
+ list.all(chars, fn(c) {
+ let is_alpha =
+ string.contains(
+ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+ c,
+ )
+ let is_digit = string.contains("0123456789", c)
+ let is_underscore = c == "_"
+ is_alpha || is_digit || is_underscore
+ })
+}
+
+/// Generate a unique registry ID from a peer name.
+///
+/// Uses erlang:phash2 for collision-resistant hashing.
+/// Deterministic: same name always produces the same ID.
+pub fn hash_peer_name(name: String) -> Int {
+ // phash2 returns 0..range-1; use 2^30 for full positive-int range
+ erlang_phash2(name, 1_073_741_824)
+}
+
+@external(erlang, "erlang", "phash2")
+fn erlang_phash2(term: String, range: Int) -> Int