diff options
Diffstat (limited to 'gleam/gossip/src')
| -rw-r--r-- | gleam/gossip/src/client.gleam | 4 | ||||
| -rw-r--r-- | gleam/gossip/src/gossip.gleam | 111 | ||||
| -rw-r--r-- | gleam/gossip/src/p2p_peer.gleam | 37 | ||||
| -rw-r--r-- | gleam/gossip/src/registry.gleam | 298 | ||||
| -rw-r--r-- | gleam/gossip/src/validation.gleam | 95 |
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 |