diff --git a/crates/idunn-daemon/src/main.rs b/crates/idunn-daemon/src/main.rs index 125a424..a4c67ab 100644 --- a/crates/idunn-daemon/src/main.rs +++ b/crates/idunn-daemon/src/main.rs @@ -1,8 +1,10 @@ use anyhow::{Context, Result, anyhow}; use cultmesh_rs::{CultMesh, CultMeshNode, CultMeshNodeOptions}; use cultnet_rs::{ - CULTNET_RUDP_PROTOCOL_ID, CultNetMessage, CultNetRawPayloadEncoding, CultNetRudpOptions, - recv_cultnet_message_rudp, send_cultnet_message_rudp, + CultNetMessage, CultNetRawPayloadEncoding, CultNetRudpPacketType, CultNetRudpSession, + CultNetRudpSessionOptions, CultNetRudpSocketTransportConnection, + CultNetRudpSocketTransportOptions, CultNetWireContract, decode_cultnet_message_from_slice, + decode_rudp_packet, encode_cultnet_message_to_vec, encode_rudp_packet, }; use odin_core::{ IdunnCommandBoundaryRecord, IdunnDaemonHealthRecord, IdunnDaemonSurgeryPlanRecord, @@ -10,6 +12,7 @@ use odin_core::{ IdunnOperatorAlarmRecord, IdunnRestartResultRecord, IdunnRudpHealthIngressRecord, IdunnRuntimeTransportCheckRecord, IdunnSwarmSurgeryPlanRecord, OdinDocuments, plan_keepalive, }; +use std::collections::HashMap; use std::env; use std::net::{SocketAddr, UdpSocket}; use std::path::PathBuf; @@ -19,6 +22,9 @@ use std::thread; use std::time::Duration; use std::time::{Instant, SystemTime, UNIX_EPOCH}; +const CULTNET_RUDP_PROTOCOL_ID: &str = "cultnet.transport.rudp.v0"; +const IDUNN_HEALTH_RUDP_CONNECTION_ID: u32 = 0x1d0d_0001; + #[derive(Clone, Debug)] struct DaemonTarget { daemon_id: String, @@ -416,29 +422,56 @@ fn runtime_transport_check(observed_at: &str) -> IdunnRuntimeTransportCheckRecor } fn verify_rudp_loopback() -> Result { - let sender = UdpSocket::bind("127.0.0.1:0")?; - let receiver = UdpSocket::bind("127.0.0.1:0")?; - let receiver_addr = receiver.local_addr()?; - let options = CultNetRudpOptions { - ack_timeout: Duration::from_millis(100), - retries: 3, - ..CultNetRudpOptions::default() - }; - let receiver_options = options.clone(); + let server_socket = UdpSocket::bind("127.0.0.1:0")?; + server_socket.set_read_timeout(Some(Duration::from_millis(100)))?; + let server_addr = server_socket.local_addr()?; + let client_socket = UdpSocket::bind("127.0.0.1:0")?; + client_socket.set_read_timeout(Some(Duration::from_millis(100)))?; let handle = thread::spawn(move || -> Result<()> { - let (message, _source, _transfer_id) = - recv_cultnet_message_rudp(&receiver, &receiver_options)?; - match message { - CultNetMessage::Hello { runtime_id, .. } if runtime_id == "idunn-daemon" => Ok(()), - other => Err(anyhow!("unexpected loopback CultNet message: {other:?}")), + let mut server = CultNetRudpSocketTransportConnection::new( + CultNetRudpSocketTransportOptions::server( + "idunn-rudp-loopback-server", + server_socket, + IDUNN_HEALTH_RUDP_CONNECTION_ID, + ), + )?; + let deadline = Instant::now() + Duration::from_secs(2); + loop { + if let Some(frame) = server.receive_once()? { + let message = + decode_cultnet_message_from_slice(&frame.payload, CultNetWireContract::CultNetSchemaV0)?; + return match message { + CultNetMessage::Hello { runtime_id, .. } if runtime_id == "idunn-daemon" => { + Ok(()) + } + other => Err(anyhow!("unexpected loopback CultNet message: {other:?}")), + }; + } + if Instant::now() >= deadline { + return Err(anyhow!("Idunn RUDP loopback timed out waiting for schema frame")); + } } }); - let transfer_id = send_cultnet_message_rudp( - &sender, - receiver_addr, - &CultNetMessage::Hello { + let mut client = CultNetRudpSocketTransportConnection::new( + CultNetRudpSocketTransportOptions::client( + "idunn-rudp-loopback-client", + client_socket, + server_addr, + IDUNN_HEALTH_RUDP_CONNECTION_ID, + ), + )?; + client.connect(Vec::new())?; + let deadline = Instant::now() + Duration::from_secs(2); + while !client.connected() { + let _ = client.receive_once()?; + client.poll_resends()?; + if Instant::now() >= deadline { + return Err(anyhow!("Idunn RUDP loopback timed out during handshake")); + } + } + let message = CultNetMessage::Hello { runtime_id: "idunn-daemon".to_string(), runtime_kind: "keepalive".to_string(), agent_id: None, @@ -447,14 +480,15 @@ fn verify_rudp_loopback() -> Result { supported_document_types: Some(vec!["idunn.runtime_transport_check".to_string()]), supported_mutation_contracts: None, supported_message_versions: Some(vec!["cultnet.hello.v0".to_string()]), + transport_profiles: Some(vec![client.profile.clone()]), supports_schema_catalog: Some(false), - }, - &options, - )?; + }; + let payload = encode_cultnet_message_to_vec(&message, CultNetWireContract::CultNetSchemaV0)?; + client.send("schema", payload)?; handle .join() .map_err(|_| anyhow!("Idunn RUDP loopback receiver thread panicked"))??; - Ok(transfer_id) + Ok(format!("connection:{IDUNN_HEALTH_RUDP_CONNECTION_ID:08x}")) } fn start_rudp_health_ingress( @@ -491,7 +525,7 @@ fn start_rudp_health_ingress( &ingress_id, local_addr, "active", - "listening for raw idunn.daemon_health documents over CultNet RUDP", + "listening for idunn.daemon_health document frames over CultNet RUDP schema channel", observed_at, ); with_store_node(options, store_lock, |node| { @@ -533,35 +567,59 @@ fn run_rudp_health_ingress_loop( options: CommonOptions, store_lock: Arc>, ) -> Result<()> { - let rudp_options = CultNetRudpOptions { - ack_timeout: Duration::from_millis(100), - retries: 3, - ..CultNetRudpOptions::default() - }; + let local_addr = socket.local_addr()?; + let mut sessions: HashMap = HashMap::new(); + let mut buffer = vec![0_u8; 65_535]; loop { - match recv_cultnet_message_rudp(&socket, &rudp_options) { - Ok((message, source, transfer_id)) => { + match socket.recv_from(&mut buffer) { + Ok((size, source)) => { let observed_at = timestamp()?; - match health_from_rudp_message(&message) { - Ok(mut health) => { - health.publication_source = "daemon-published".to_string(); - health.transport = CULTNET_RUDP_PROTOCOL_ID.to_string(); - with_store_node(&options, &store_lock, |node| { - node.put(&health.daemon_id, &health)?; - Ok(()) - })?; - println!( - "Idunn accepted RUDP health for {} from {} transfer {}.", - health.daemon_id, source, transfer_id - ); + match handle_rudp_health_datagram(&socket, &mut sessions, &buffer[..size], source) + { + Ok(frames) => { + for frame in frames { + let message = decode_cultnet_message_from_slice( + &frame.payload, + CultNetWireContract::CultNetSchemaV0, + )?; + match health_from_rudp_message(&message) { + Ok(mut health) => { + health.publication_source = "daemon-published".to_string(); + health.transport = CULTNET_RUDP_PROTOCOL_ID.to_string(); + with_store_node(&options, &store_lock, |node| { + node.put(&health.daemon_id, &health)?; + Ok(()) + })?; + println!( + "Idunn accepted RUDP health for {} from {} over {}.", + health.daemon_id, source, frame.channel_id + ); + } + Err(error) => { + let failed = rudp_health_ingress_record( + "idunn-rudp-health-ingress", + local_addr, + "degraded", + &format!( + "rejected RUDP health schema frame from {source}: {error}" + ), + &observed_at, + ); + with_store_node(&options, &store_lock, |node| { + node.put(&failed.ingress_id, &failed)?; + Ok(()) + })?; + } + } + } } Err(error) => { let failed = rudp_health_ingress_record( "idunn-rudp-health-ingress", - socket.local_addr()?, + local_addr, "degraded", - &format!("rejected RUDP health message from {source}: {error}"), + &format!("rejected RUDP health datagram from {source}: {error}"), &observed_at, ); with_store_node(&options, &store_lock, |node| { @@ -572,17 +630,70 @@ fn run_rudp_health_ingress_loop( } } Err(error) - if error.downcast_ref::().is_some_and(|io| { - matches!( - io.kind(), - std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut - ) - }) => {} - Err(error) => return Err(error), + if matches!( + error.kind(), + std::io::ErrorKind::WouldBlock + | std::io::ErrorKind::TimedOut + | std::io::ErrorKind::ConnectionReset + | std::io::ErrorKind::ConnectionAborted + ) => {} + Err(error) => return Err(error.into()), } } } +fn handle_rudp_health_datagram( + socket: &UdpSocket, + sessions: &mut HashMap, + wire: &[u8], + source: SocketAddr, +) -> Result> { + let packet = decode_rudp_packet(wire)?; + if packet.connection_id != IDUNN_HEALTH_RUDP_CONNECTION_ID { + return Err(anyhow!( + "unexpected RUDP connection id {:08x}", + packet.connection_id + )); + } + + let session = sessions.entry(source).or_insert_with(|| { + CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: IDUNN_HEALTH_RUDP_CONNECTION_ID, + initial_sequence: 1, + resend_delay_ms: 100, + max_pending_reliable_packets: None, + }) + }); + let now = unix_epoch_millis()?; + + if packet.packet_type == CultNetRudpPacketType::Connect { + let accept = session.accept_connect(&packet, now, Vec::new())?; + socket.send_to(&encode_rudp_packet(&accept)?, source)?; + return Ok(Vec::new()); + } + + let result = session.receive(&packet, now)?; + if let Some(reply) = result.reply { + socket.send_to(&encode_rudp_packet(&reply)?, source)?; + } + let frames = result + .delivered + .into_iter() + .map(|frame| cultnet_rs::CultNetTransportFrame { + channel_id: frame.channel_id, + payload: frame.payload, + }) + .collect::>(); + if packet.packet_type == CultNetRudpPacketType::Accept || !frames.is_empty() { + let ack = session.create_ack(); + socket.send_to(&encode_rudp_packet(&ack)?, source)?; + } + if result.disconnected || !frames.is_empty() { + sessions.remove(&source); + } + Ok(frames) +} + fn health_from_rudp_message(message: &CultNetMessage) -> Result { let CultNetMessage::DocumentPutRaw { document, .. } = message else { return Err(anyhow!("expected cultnet.document_put_raw.v0")); @@ -636,9 +747,9 @@ fn swarm_surgery_plan( targets: &[DaemonTarget], updated_at: &str, ) -> IdunnSwarmSurgeryPlanRecord { - let has_odin = targets.iter().any(|target| target.daemon_id == "odin"); - let next_target = if has_odin { - "odin" + let has_stonks = targets.iter().any(|target| target.daemon_id == "stonks"); + let next_target = if has_stonks { + "stonks" } else if let Some(target) = targets.iter().find(|target| target.enabled) { target.daemon_id.as_str() } else { @@ -672,11 +783,11 @@ fn swarm_surgery_plan( "5. Delete or demote compatibility probes once every target has daemon-owned publication and advertised lifecycle authority.".to_string(), ], current_phase: - "Phase 5: move Odin's own provider health from compatibility command evidence to daemon-published RUDP state." + "Phase 6: move Stonks market-provider health from HTTP compatibility evidence to daemon-published RUDP state." .to_string(), next_target: next_target.to_string(), cut_line: - "All Muninn lanes now publish daemon-owned RUDP health. Odin remains the next critical provider-health cut before its local command probe can be demoted." + "Muninn, Idunn, and Odin now exercise daemon-owned RUDP health locally. Stonks is the next TypeScript provider cut; Raven task repairs remain queued until the host is reachable." .to_string(), verification_layer: "CultMesh keepalive store records plus live Idunn decision cycles, not process exit codes or chat summaries." @@ -1635,6 +1746,14 @@ fn timestamp() -> Result { Ok(format!("unix:{seconds}")) } +fn unix_epoch_millis() -> Result { + let millis = SystemTime::now() + .duration_since(UNIX_EPOCH) + .context("system clock is before Unix epoch")? + .as_millis(); + u64::try_from(millis).context("system clock milliseconds exceeded u64") +} + fn help_text() -> &'static str { "Usage: idunn --daemon [--name ] [--verse ] [--store ] [--health-command ] [--deploy-command ] [--restart-command ] [--operator-alarm-command ] [--rudp-health-bind ] [--execute] [--interval-seconds ] [--command-timeout-seconds ] [--repo-root ] [--swarm-profile ]\n\nIdunn can run one manual daemon probe lane with --daemon, or one built-in swarm supervisor with --swarm-profile starfire-local." } @@ -1688,7 +1807,7 @@ mod tests { } #[test] - fn swarm_surgery_plan_names_odin_after_muninn_cuts() { + fn swarm_surgery_plan_names_stonks_after_odin_cut() { let starfire_muninn = DaemonTarget { daemon_id: "starfire-muninn".to_string(), verse_id: "starfire.local".to_string(), @@ -1742,18 +1861,29 @@ mod tests { enabled: true, interval_seconds: 30, }; + let stonks = DaemonTarget { + daemon_id: "stonks".to_string(), + verse_id: "starfire.local".to_string(), + name: "Stonks".to_string(), + health_contract: health_contract("stonks.cultnet-rudp-market-health", "failed"), + health_command: Some("health-stonks.cmd".to_string()), + deploy_command: None, + restart_command: Some("restart-stonks.cmd".to_string()), + enabled: true, + interval_seconds: 30, + }; let plan = swarm_surgery_plan( "starfire-local", - &[odin, starfire_muninn, nightwing_muninn, raven_muninn], + &[odin, stonks, starfire_muninn, nightwing_muninn, raven_muninn], "unix:100", ); assert_eq!(plan.plan_id, "swarm-surgery:starfire-local"); assert_eq!(plan.status, "active-transport-migration"); - assert_eq!(plan.next_target, "odin"); - assert!(plan.current_phase.contains("Odin")); - assert!(plan.cut_line.contains("All Muninn lanes")); + assert_eq!(plan.next_target, "stonks"); + assert!(plan.current_phase.contains("Stonks")); + assert!(plan.cut_line.contains("Muninn, Idunn, and Odin")); assert!(plan.verification_layer.contains("CultMesh keepalive store")); assert!( plan.invariants diff --git a/crates/muninn-daemon/src/main.rs b/crates/muninn-daemon/src/main.rs index 745e5dd..289508a 100644 --- a/crates/muninn-daemon/src/main.rs +++ b/crates/muninn-daemon/src/main.rs @@ -4,8 +4,9 @@ use cultmesh_rs::{ CultMeshStreamCatalog, CultMeshStreamClock, CultMeshStreamDescriptor, CultMeshStreamKind, }; use cultnet_rs::{ - CULTNET_RUDP_PROTOCOL_ID, CultNetMessage, CultNetRawDocumentRecord, CultNetRawPayloadEncoding, - CultNetRudpOptions, send_cultnet_message_rudp, + CultNetMessage, CultNetRawDocumentRecord, CultNetRawPayloadEncoding, + CultNetRudpSocketTransportConnection, CultNetRudpSocketTransportOptions, CultNetWireContract, + encode_cultnet_message_to_vec, }; use odin_core::{ IdunnDaemonHealthRecord, MuninnCaptureStreamRecord, MuninnMoveControllerStateRecord, @@ -34,6 +35,9 @@ use std::os::unix::fs::OpenOptionsExt; #[cfg(windows)] use std::os::windows::ffi::OsStrExt; +const CULTNET_RUDP_PROTOCOL_ID: &str = "cultnet.transport.rudp.v0"; +const IDUNN_HEALTH_RUDP_CONNECTION_ID: u32 = 0x1d0d_0001; + #[derive(Clone, Debug, PartialEq, Eq)] enum Mode { Serve, @@ -2069,13 +2073,32 @@ fn publish_idunn_rudp_health( }; let socket = UdpSocket::bind(bind_address) .with_context(|| format!("binding Muninn RUDP sender at {bind_address}"))?; - send_cultnet_message_rudp( - &socket, - options.endpoint, - &message, - &CultNetRudpOptions::default(), - ) - .with_context(|| format!("sending Idunn health to {}", options.endpoint))?; + socket.set_read_timeout(Some(Duration::from_millis(100)))?; + let mut transport = CultNetRudpSocketTransportConnection::new( + CultNetRudpSocketTransportOptions::client( + "muninn-daemon", + socket, + options.endpoint, + IDUNN_HEALTH_RUDP_CONNECTION_ID, + ), + )?; + transport.connect(Vec::new())?; + let deadline = Instant::now() + Duration::from_secs(2); + while !transport.connected() { + let _ = transport.receive_once()?; + transport.poll_resends()?; + if Instant::now() >= deadline { + return Err(anyhow!( + "timed out connecting Muninn RUDP sender to {}", + options.endpoint + )); + } + } + let payload = encode_cultnet_message_to_vec(&message, CultNetWireContract::CultNetSchemaV0) + .context("encoding Idunn health CultNet message")?; + transport + .send("schema", payload) + .with_context(|| format!("sending Idunn health to {}", options.endpoint))?; Ok(()) } @@ -2796,16 +2819,33 @@ mod tests { #[test] fn idunn_rudp_health_publisher_sends_raw_daemon_health_document() { let receiver = UdpSocket::bind("127.0.0.1:0").unwrap(); + receiver + .set_read_timeout(Some(Duration::from_secs(1))) + .unwrap(); let receiver_addr = receiver.local_addr().unwrap(); let handle = thread::spawn(move || { - cultnet_rs::recv_cultnet_message_rudp( - &receiver, - &CultNetRudpOptions { - ack_timeout: Duration::from_secs(1), - ..CultNetRudpOptions::default() - }, + let mut transport = CultNetRudpSocketTransportConnection::new( + CultNetRudpSocketTransportOptions::server( + "idunn-test", + receiver, + IDUNN_HEALTH_RUDP_CONNECTION_ID, + ), ) - .unwrap() + .unwrap(); + let deadline = Instant::now() + Duration::from_secs(2); + loop { + if let Some(frame) = transport.receive_once().unwrap() { + return cultnet_rs::decode_cultnet_message_from_slice( + &frame.payload, + CultNetWireContract::CultNetSchemaV0, + ) + .unwrap(); + } + transport.poll_resends().unwrap(); + if Instant::now() >= deadline { + panic!("timed out waiting for Muninn RUDP health frame"); + } + } }); let options = IdunnRudpHealthOptions { endpoint: receiver_addr, @@ -2815,7 +2855,7 @@ mod tests { publish_idunn_rudp_health(&options, "active", "Muninn healthy", "unix:100").unwrap(); - let (message, _, _) = handle.join().unwrap(); + let message = handle.join().unwrap(); let CultNetMessage::DocumentPutRaw { document, .. } = message else { panic!("expected raw document put"); }; diff --git a/docs/architecture.md b/docs/architecture.md index e9f0358..2447273 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -60,9 +60,13 @@ Odin's executable body is split by ownership: ports, normalization, and CultMesh/CultCache repository boundaries. This is the replacement spine; JavaScript remains legacy runtime/probe scaffolding until each organ has crossed the typed boundary. -- `src/odin-coordinator.cjs`: process lifecycle, refresh loop, persistence, health, and transport wiring. +- `src/odin-coordinator.cjs`: process lifecycle, serialized refresh loop, + persistence, health, and transport wiring. Refreshes must not overlap because + a refresh publishes Odin's daemon health. - `src/odin/config.cjs`: runtime paths, seed deck URLs, intervals, and CultLib module path setup. - `src/odin/documents.cjs`: CultCache/CultMesh document definitions accepted by Odin. +- `src/odin/idunn-rudp.cjs`: daemon-owned Odin provider health publication to + Idunn over the canonical CultNet RUDP `schema` channel. - `src/odin/probes.cjs`: local Docker/ADB probes plus demoted TCP/SSH/GPU compatibility probes while daemon CultLib dependencies migrate to CultNet RUDP health publication. diff --git a/docs/idunn.md b/docs/idunn.md index e9903da..9b9ecfc 100644 --- a/docs/idunn.md +++ b/docs/idunn.md @@ -134,9 +134,10 @@ idunn.rudp_health_ingress.v1 over `cultnet.transport.rudp.v0`. TCP, HTTP, WebSocket, and ad hoc port probes are migration debt, tolerated only at xenos/legacy boundaries and while the daemon's CultLib dependency has not yet been updated. -- Rust now has a narrow `cultnet.transport.rudp.v0` substrate in - `vendor/cultnet-rs`: one CultNet message per acknowledged UDP datagram with - timeout/retry semantics. This removes "Rust cannot speak RUDP" as a substrate +- Rust now shares the canonical cross-runtime `cultnet.transport.rudp.v0` + substrate in `vendor/cultnet-rs`: CNR0 packets, sessions, channels, reliable + schema frames, and timeout/retry semantics matching the TypeScript/Python + CultLib implementations. This removes "Rust cannot speak RUDP" as a substrate excuse. It does not make any daemon fully migrated until that daemon publishes its health and command boundary through the RUDP path and Idunn consumes that daemon-owned publication instead of the compatibility command. @@ -148,11 +149,15 @@ idunn.rudp_health_ingress.v1 `idunn.rudp_health_ingress.v1`. The Starfire local supervisor binds `0.0.0.0:17870` so host-local publishers can use `127.0.0.1:17870` and WireGuard peers such as Nightwing can publish to `10.77.0.2:17870`. That ingress - accepts only raw `idunn.daemon_health` CultNet document puts, decodes the - typed MessagePack payload, and writes it into the keepalive store. It does - not grant deploy/restart authority and it does not make compatibility probes - owners; it is the first daemon-owned health publication path Idunn can - consume. + accepts only raw `idunn.daemon_health` CultNet document puts on the `schema` + channel, decodes the typed MessagePack payload, and writes it into the + keepalive store. Each one-shot publisher gets its own RUDP session from its + UDP source address and the session is discarded after a delivered health + frame. Windows UDP `ConnectionReset`/`ConnectionAborted` reports from closed + one-shot clients are nonfatal ingress noise, not a reason to kill the worker. + The ingress does not grant deploy/restart authority and it does not make + compatibility probes owners; it is the first daemon-owned health publication + path Idunn can consume. - During each target cycle, fresh daemon-published RUDP health wins over the local compatibility command. Idunn accepts it only when the daemon id, health contract, `publication_source=daemon-published`, transport @@ -260,16 +265,19 @@ The local swarm mode owns: Yggdrasil checks. Current plan surface: `idunn.swarm_surgery_plan.v1` for profile -`starfire-local` treats the Muninn Rust lanes as completed cuts. Muninn's -`--health` mode publishes `idunn.daemon_health` over RUDP; Starfire publishes to -local Idunn, while Nightwing and Raven publish over WireGuard to -`10.77.0.2:17870` using their target daemon ids and health contracts. Live Idunn -cycles accept those records before command-probe fallback. The plan's current -phase now points at Odin's own provider-health lane. +`starfire-local` treats the Muninn Rust lanes and Odin's local provider-health +lane as completed local substrate cuts. Muninn's `--health` mode publishes +`idunn.daemon_health` over RUDP; Starfire publishes to local Idunn, while +Nightwing and Raven publish over WireGuard to `10.77.0.2:17870` using their +target daemon ids and health contracts. Odin now publishes +`odin.cultnet-rudp-provider-health` over the same RUDP ingress after each +provider refresh. Live Idunn cycles accept these records before command-probe +fallback. -Next: make Odin publish its own provider health over daemon-owned RUDP state, -then continue runtime-by-runtime until compatibility probes can be deleted or -demoted. +Next: move Stonks market-provider health off HTTP compatibility evidence and +onto daemon-owned RUDP state, then continue runtime-by-runtime until +compatibility probes can be deleted or demoted. Raven Muninn task action repair +is queued separately and remains blocked while Raven is unreachable. No ad hoc JSON manifest, HTTP endpoint, TCP socket, or WebSocket bridge may become the live state owner. Debug projections are fine when they name the diff --git a/scripts/start-odin.ps1 b/scripts/start-odin.ps1 index ad3ea56..12249c6 100644 --- a/scripts/start-odin.ps1 +++ b/scripts/start-odin.ps1 @@ -1,6 +1,9 @@ param( [int] $Port = 8797, [string] $StateDir = "E:\Projects\Odin\scratch\odin", + [string] $IdunnRudpHealth = "127.0.0.1:17870", + [string] $IdunnDaemon = "odin", + [string] $IdunnHealthContract = "odin.cultnet-rudp-provider-health", [switch] $Foreground ) @@ -29,7 +32,10 @@ $env:NODE_PATH = "E:\Projects\CultLib\packages" $args = @( $scriptPath, "--port", "$Port", - "--stateDir", $StateDir + "--stateDir", $StateDir, + "--idunn-rudp-health", $IdunnRudpHealth, + "--idunn-daemon", $IdunnDaemon, + "--idunn-health-contract", $IdunnHealthContract ) if ($Foreground) { diff --git a/src/Idunn/README.md b/src/Idunn/README.md index 3ed15db..7b5e88f 100644 --- a/src/Idunn/README.md +++ b/src/Idunn/README.md @@ -181,9 +181,11 @@ walk through the same door. The local swarm also opens a RUDP health ingress at `127.0.0.1:17870` unless started with `--rudp-health-bind none`. It accepts raw -`idunn.daemon_health` document puts over `cultnet.transport.rudp.v0` and writes -them into the keepalive store. That is daemon-owned health publication, not -restart/deploy authority. +`idunn.daemon_health` document puts on the canonical CNR0 RUDP `schema` channel +and writes them into the keepalive store. That is daemon-owned health +publication, not restart/deploy authority. On Windows, UDP reset reports from +closed one-shot publishers are treated as nonfatal ingress noise so one accepted +health frame cannot kill the listener. When a fresh daemon-published RUDP health record exists for a target, Idunn uses that record for keepalive planning before falling back to the local command @@ -191,17 +193,17 @@ probe. The record must match the daemon id, health contract, RUDP transport, and freshness window; otherwise the compatibility probe remains fallback evidence. -The next cuts are updating daemon CultLib dependencies so health and command -boundaries publish through `cultnet.transport.rudp.v0`, switching Idunn to those -daemon-owned records, promoting the built-in target catalog into Odin-ingested -service/provider records, keeping named adapters only for legacy service-manager -crossings, and replacing the local operator alarm bridge with a fully -Bifrost-owned notification request record. +The next cut is Stonks: market-provider health must publish through +`cultnet.transport.rudp.v0` instead of remaining HTTP compatibility evidence. +After that, continue daemon-by-daemon, promote the built-in target catalog into +Odin-ingested service/provider records, keep named adapters only for legacy +service-manager crossings, and replace the local operator alarm bridge with a +fully Bifrost-owned notification request record. Rust no longer gets to claim the transport is imaginary: -`vendor/cultnet-rs` includes a narrow stop-and-wait -`cultnet.transport.rudp.v0` path for acknowledged CultNet messages over UDP. -That is substrate only. Idunn still marks daemon profiles as +`vendor/cultnet-rs` includes the canonical CNR0 `cultnet.transport.rudp.v0` +session path for acknowledged CultNet messages over UDP. That is substrate +only. Idunn still marks daemon profiles as `migration-required` until each daemon actually publishes health and command boundary records through that path. diff --git a/src/odin-coordinator.cjs b/src/odin-coordinator.cjs index 3f52f23..277df8b 100644 --- a/src/odin-coordinator.cjs +++ b/src/odin-coordinator.cjs @@ -7,12 +7,14 @@ const path = require("path"); const { buildConfig, loadCultRuntime } = require("./odin/config.cjs"); const { defineOdinDocuments } = require("./odin/documents.cjs"); const { createInterfaceDiscovery } = require("./odin/interfaces.cjs"); +const { createIdunnRudpHealthPublisher, publishIdunnRudpHealth } = require("./odin/idunn-rudp.cjs"); const { createLayoutStore } = require("./odin/layout.cjs"); const { createStateBuilder } = require("./odin/state.cjs"); const { broadcastState, createDashboardServer } = require("./odin/websocket.cjs"); const config = buildConfig(process.argv.slice(2)); fs.mkdirSync(config.stateDir, { recursive: true }); +const idunnRudpHealthPublisher = createIdunnRudpHealthPublisher(config.idunnRudpHealth); const cultRuntime = loadCultRuntime(); if (cultRuntime.error) { @@ -67,8 +69,14 @@ async function main() { console.log(`Durable surface cache: ${config.cachePath}`); await refresh(dashboardServer.clients); - setInterval(() => { - refresh(dashboardServer.clients).catch((error) => console.error("refresh failed:", error)); + scheduleRefresh(dashboardServer.clients); +} + +function scheduleRefresh(clients) { + setTimeout(() => { + refresh(clients) + .catch((error) => console.error("refresh failed:", error)) + .finally(() => scheduleRefresh(clients)); }, config.intervalMs); } @@ -106,6 +114,7 @@ async function refresh(clients) { error: null, startedAt: new Date(started).toISOString(), }; + await publishOdinHealth("active", `Odin provider catalog refreshed in ${lastRefresh.durationMs}ms`); } catch (error) { lastRefresh = { completedAt: new Date().toISOString(), @@ -113,10 +122,24 @@ async function refresh(clients) { error: error.message, startedAt: new Date(started).toISOString(), }; + await publishOdinHealth("failed", `Odin provider refresh failed: ${error.message}`); throw error; } } +async function publishOdinHealth(state, detail) { + if (!idunnRudpHealthPublisher) return; + try { + await publishIdunnRudpHealth(idunnRudpHealthPublisher, { + state, + detail, + observedAt: new Date().toISOString(), + }); + } catch (error) { + console.error("Idunn RUDP health publish failed:", error.message); + } +} + async function persistState(state) { fs.writeFileSync(path.join(config.stateDir, "latest-surface.json"), JSON.stringify(state, null, 2), "utf8"); if (!meshNodePromise || !documents.surfaceDefinition) { diff --git a/src/odin/config.cjs b/src/odin/config.cjs index edc379a..3885ad2 100644 --- a/src/odin/config.cjs +++ b/src/odin/config.cjs @@ -29,6 +29,11 @@ function buildConfig(argv) { const gamecultTextDocumentStorePath = args.gamecultTextDocumentStorePath || path.join(repoRoot, "..", "VoidBot", ".voidbot", "private", "gamecult-text-documents.cc"); const stonksStateUrl = args.stonksStateUrl || "http://127.0.0.1:8802/market/state"; const stonksBurstSize = Math.max(1, Number(args.stonksBurstSize || 8)); + const idunnRudpHealth = args["idunn-rudp-health"] ? { + endpoint: String(args["idunn-rudp-health"]), + daemonId: String(args["idunn-daemon"] || "odin"), + healthContract: String(args["idunn-health-contract"] || "odin.cultnet-rudp-provider-health"), + } : null; const defaultInterfaceBindingStores = [ path.join(repoRoot, "..", "VoidBot", ".voidbot", "status", "cultmesh", "voidbot-swarm-state.cc"), path.join(repoRoot, "..", "Bifrost", ".bifrost", "provider-advertisement.cc"), @@ -48,6 +53,7 @@ function buildConfig(argv) { gamecultTextDocumentStorePath, host, interfaceBindingStores, + idunnRudpHealth, intervalMs, layoutPath, observationFreshSeconds, diff --git a/src/odin/idunn-rudp.cjs b/src/odin/idunn-rudp.cjs new file mode 100644 index 0000000..733129c --- /dev/null +++ b/src/odin/idunn-rudp.cjs @@ -0,0 +1,254 @@ +"use strict"; + +const dgram = require("dgram"); +const path = require("path"); + +const { + CultNetRudpSession, + decodeRudpPacket, + encodeCultNetMessageForWire, + encodeRudpPacket, +} = require("cultnet-ts"); + +const { encode } = require(path.resolve( + __dirname, + "..", + "..", + "..", + "CultLib", + "node_modules", + "@msgpack", + "msgpack", +)); + +const CULTNET_RUDP_PROTOCOL_ID = "cultnet.transport.rudp.v0"; +const IDUNN_HEALTH_RUDP_CONNECTION_ID = 0x1d0d0001; + +function createIdunnRudpHealthPublisher(options) { + if (!options) return null; + const endpoint = parseEndpoint(options.endpoint); + return { + daemonId: options.daemonId, + endpoint, + healthContract: options.healthContract, + }; +} + +async function publishIdunnRudpHealth(publisher, health) { + if (!publisher) return; + + const socket = dgram.createSocket(endpointFamily(publisher.endpoint.host)); + await bindSocket(socket, publisher.endpoint); + const receiver = createPacketReceiver(socket); + const session = new CultNetRudpSession({ + connectionId: IDUNN_HEALTH_RUDP_CONNECTION_ID, + initialSequence: 1, + resendDelayMs: 100, + }); + try { + const connect = session.createConnect(Date.now(), new Uint8Array()); + await sendPacket(socket, publisher.endpoint, connect); + await receiveUntil( + receiver, + session, + publisher.endpoint, + (packet) => packet.packetType === "accept", + 5000, + "accept", + ); + + const observedAt = health.observedAt || new Date().toISOString(); + const record = { + daemonId: publisher.daemonId, + state: health.state, + detail: health.detail, + observedAt, + healthContract: publisher.healthContract, + publicationSource: "daemon-published", + transport: CULTNET_RUDP_PROTOCOL_ID, + }; + const payload = encode([ + record.daemonId, + record.state, + record.detail, + record.observedAt, + record.healthContract, + record.publicationSource, + record.transport, + ]); + const message = { + schemaVersion: "cultnet.document_put_raw.v0", + messageId: `odin-health:${publisher.daemonId}:${observedAt.replace(/[:.]/g, "-")}`, + document: { + schemaId: "idunn.daemon_health", + recordKey: publisher.daemonId, + storedAt: observedAt, + payloadEncoding: "messagepack", + payload, + sourceRuntimeId: "odin-coordinator", + sourceRole: "daemon-health-publisher", + tags: [CULTNET_RUDP_PROTOCOL_ID], + }, + }; + const wirePayload = encode(encodeCultNetMessageForWire(message, "cultnet.schema.v0")); + const dataPackets = session.sendMany("schema", wirePayload, { + reliable: true, + ordered: true, + nowMs: Date.now(), + }); + const ack = receiveUntil( + receiver, + session, + publisher.endpoint, + (packet) => packet.packetType === "ack", + 500, + "ack", + ).catch(() => undefined); + for (const packet of dataPackets) { + await sendPacket(socket, publisher.endpoint, packet); + } + await ack; + } finally { + receiver.close(); + socket.close(); + } +} + +async function bindSocket(socket, endpoint) { + await new Promise((resolve, reject) => { + socket.once("error", reject); + socket.bind(0, endpoint.host.includes(":") ? "::" : "0.0.0.0", () => { + socket.off("error", reject); + resolve(); + }); + }); +} + +function parseEndpoint(value) { + const text = String(value || "").trim(); + const ipv6 = text.match(/^\[([^\]]+)\]:(\d+)$/); + if (ipv6) return { host: ipv6[1], port: parsePort(ipv6[2]) }; + const index = text.lastIndexOf(":"); + if (index <= 0) { + throw new Error(`Idunn RUDP endpoint must be host:port, got "${value}".`); + } + return { host: text.slice(0, index), port: parsePort(text.slice(index + 1)) }; +} + +function parsePort(value) { + const port = Number(value); + if (!Number.isInteger(port) || port <= 0 || port > 65535) { + throw new Error(`Idunn RUDP endpoint port is invalid: ${value}`); + } + return port; +} + +function endpointFamily(host) { + return host.includes(":") ? "udp6" : "udp4"; +} + +async function receiveUntil(receiver, session, endpoint, predicate, timeoutMs, label) { + const deadline = Date.now() + timeoutMs; + while (Date.now() < deadline) { + try { + const packet = await receiver.next(Math.min(100, deadline - Date.now()), label); + const result = session.receive(packet, Date.now()); + if (result.reply) { + throw new Error("Odin RUDP health publisher received an unexpected reply-required packet."); + } + if (predicate(packet)) { + return; + } + } catch (error) { + if (error.code !== "ETIMEDOUT") { + throw error; + } + } + for (const packet of session.dueResends(Date.now())) { + await sendPacket(receiver.socket, endpoint, packet); + } + } + throw new Error(`timed out waiting for Idunn RUDP ${label} response after ${timeoutMs}ms`); +} + +function createPacketReceiver(socket) { + const packets = []; + const waiters = []; + const errors = []; + + const resolveNext = () => { + while (waiters.length > 0 && (packets.length > 0 || errors.length > 0)) { + const waiter = waiters.shift(); + clearTimeout(waiter.timer); + if (errors.length > 0) { + waiter.reject(errors.shift()); + } else { + waiter.resolve(packets.shift()); + } + } + }; + const onMessage = (wire) => { + try { + packets.push(decodeRudpPacket(wire)); + } catch (error) { + errors.push(error); + } + resolveNext(); + }; + const onError = (error) => { + errors.push(error); + resolveNext(); + }; + + socket.on("message", onMessage); + socket.on("error", onError); + + return { + socket, + next(timeoutMs, label = "packet") { + if (packets.length > 0) return Promise.resolve(packets.shift()); + if (errors.length > 0) return Promise.reject(errors.shift()); + return new Promise((resolve, reject) => { + const waiter = { + resolve, + reject, + timer: setTimeout(() => { + const index = waiters.indexOf(waiter); + if (index >= 0) waiters.splice(index, 1); + const error = new Error(`timed out waiting for Idunn RUDP ${label}`); + error.code = "ETIMEDOUT"; + reject(error); + }, Math.max(1, timeoutMs)), + }; + waiters.push(waiter); + }); + }, + close() { + socket.off("message", onMessage); + socket.off("error", onError); + while (waiters.length > 0) { + const waiter = waiters.shift(); + clearTimeout(waiter.timer); + const error = new Error("Odin RUDP health publisher closed."); + error.code = "ECLOSED"; + waiter.reject(error); + } + }, + }; +} + +async function sendPacket(socket, endpoint, packet) { + const wire = encodeRudpPacket(packet); + await new Promise((resolve, reject) => { + socket.send(wire, endpoint.port, endpoint.host, (error) => { + if (error) reject(error); + else resolve(); + }); + }); +} + +module.exports = { + CULTNET_RUDP_PROTOCOL_ID, + createIdunnRudpHealthPublisher, + publishIdunnRudpHealth, +}; diff --git a/vendor/cultnet-rs/contracts/cultnet.hello.schema.json b/vendor/cultnet-rs/contracts/cultnet.hello.schema.json index bced757..a557dc3 100644 --- a/vendor/cultnet-rs/contracts/cultnet.hello.schema.json +++ b/vendor/cultnet-rs/contracts/cultnet.hello.schema.json @@ -30,6 +30,12 @@ "type": "array", "items": { "type": "string", "minLength": 1 } }, + "transportProfiles": { + "type": "array", + "items": { + "$ref": "./cultnet.transport-profile.schema.json" + } + }, "supportsSchemaCatalog": { "type": "boolean" } } } diff --git a/vendor/cultnet-rs/contracts/cultnet.transport-profile.schema.json b/vendor/cultnet-rs/contracts/cultnet.transport-profile.schema.json new file mode 100644 index 0000000..cc237e7 --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.transport-profile.schema.json @@ -0,0 +1,81 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.transport-profile.schema.json", + "title": "CultNet Transport Profile", + "type": "object", + "required": [ + "schemaVersion", + "runtimeId", + "transports" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.transport_profile.v0" }, + "runtimeId": { "type": "string", "minLength": 1 }, + "transports": { + "type": "array", + "items": { + "type": "object", + "required": [ + "transportId", + "protocol", + "channels" + ], + "additionalProperties": false, + "properties": { + "transportId": { "type": "string", "minLength": 1 }, + "protocol": { + "type": "string", + "enum": [ + "tcp_framed", + "litenetlib", + "websocket", + "rudp" + ] + }, + "host": { "type": "string", "minLength": 1 }, + "port": { "type": "integer", "minimum": 1, "maximum": 65535 }, + "path": { "type": "string", "minLength": 1 }, + "discoveryGroup": { "type": "string", "minLength": 1 }, + "wireContracts": { + "type": "array", + "items": { "type": "string", "minLength": 1 } + }, + "channels": { + "type": "array", + "items": { + "type": "object", + "required": [ + "channelId", + "delivery", + "ordering" + ], + "additionalProperties": false, + "properties": { + "channelId": { "type": "string", "minLength": 1 }, + "delivery": { + "type": "string", + "enum": [ + "reliable", + "unreliable" + ] + }, + "ordering": { + "type": "string", + "enum": [ + "ordered", + "unordered", + "sequenced" + ] + }, + "maxPayloadBytes": { "type": "integer", "minimum": 1 }, + "maxFragmentBytes": { "type": "integer", "minimum": 1 }, + "maxPendingReliablePackets": { "type": "integer", "minimum": 1 } + } + } + } + } + } + } + } +} diff --git a/vendor/cultnet-rs/src/contracts.rs b/vendor/cultnet-rs/src/contracts.rs index 24be7b4..a7d999e 100644 --- a/vendor/cultnet-rs/src/contracts.rs +++ b/vendor/cultnet-rs/src/contracts.rs @@ -81,6 +81,70 @@ pub struct CultNetDocumentMutationContract { pub notes: Option>, } +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct CultNetTransportProfile { + pub schema_version: String, + pub runtime_id: String, + pub transports: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct CultNetTransportDescriptor { + pub transport_id: String, + pub protocol: CultNetTransportProtocol, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub host: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub port: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub path: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub discovery_group: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub wire_contracts: Option>, + pub channels: Vec, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum CultNetTransportProtocol { + TcpFramed, + Litenetlib, + Websocket, + Rudp, +} + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct CultNetTransportChannel { + pub channel_id: String, + pub delivery: CultNetTransportDelivery, + pub ordering: CultNetTransportOrdering, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub max_payload_bytes: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub max_fragment_bytes: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub max_pending_reliable_packets: Option, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum CultNetTransportDelivery { + Reliable, + Unreliable, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum CultNetTransportOrdering { + Ordered, + Unordered, + Sequenced, +} + #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct CultNetRawDocumentRecord { @@ -137,6 +201,8 @@ pub enum CultNetMessage { #[serde(default, skip_serializing_if = "Option::is_none")] supported_message_versions: Option>, #[serde(default, skip_serializing_if = "Option::is_none")] + transport_profiles: Option>, + #[serde(default, skip_serializing_if = "Option::is_none")] supports_schema_catalog: Option, }, #[serde(rename = "cultnet.login.v0", rename_all = "camelCase")] @@ -287,6 +353,7 @@ fn validate_message(message: &CultNetMessage) -> Result<()> { supported_document_types, supported_mutation_contracts, supported_message_versions, + transport_profiles: _, supports_schema_catalog: _, } => { require_non_empty(runtime_id, "runtimeId")?; diff --git a/vendor/cultnet-rs/src/lib.rs b/vendor/cultnet-rs/src/lib.rs index da09596..bc804d3 100644 --- a/vendor/cultnet-rs/src/lib.rs +++ b/vendor/cultnet-rs/src/lib.rs @@ -4,6 +4,7 @@ mod replication; mod rudp; mod schema_discovery; mod security; +mod transport; pub use contracts::*; pub use framing::*; @@ -11,3 +12,4 @@ pub use replication::*; pub use rudp::*; pub use schema_discovery::*; pub use security::*; +pub use transport::*; diff --git a/vendor/cultnet-rs/src/rudp.rs b/vendor/cultnet-rs/src/rudp.rs index e922378..5cb90e0 100644 --- a/vendor/cultnet-rs/src/rudp.rs +++ b/vendor/cultnet-rs/src/rudp.rs @@ -1,312 +1,1191 @@ -use crate::{ - CultNetMessage, CultNetWireContract, decode_cultnet_message_from_slice, - encode_cultnet_message_to_vec, -}; -use anyhow::{Result, anyhow}; -use serde::{Deserialize, Serialize}; +use anyhow::Result; +use anyhow::anyhow; +use std::collections::BTreeMap; +use std::collections::BTreeSet; +use std::collections::VecDeque; use std::io::ErrorKind; -use std::net::{SocketAddr, UdpSocket}; -use std::time::Duration; -use uuid::Uuid; +use std::net::SocketAddr; +use std::net::UdpSocket; +use std::time::SystemTime; +use std::time::UNIX_EPOCH; -pub const CULTNET_RUDP_PROTOCOL_ID: &str = "cultnet.transport.rudp.v0"; -pub const DEFAULT_CULTNET_RUDP_MAX_DATAGRAM_BYTES: usize = 60_000; -pub const DEFAULT_CULTNET_RUDP_RETRIES: usize = 5; -pub const DEFAULT_CULTNET_RUDP_ACK_TIMEOUT: Duration = Duration::from_millis(250); +use crate::CultNetTransportChannel; +use crate::CultNetTransportDelivery; +use crate::CultNetTransportDescriptor; +use crate::CultNetTransportFrame; +use crate::CultNetTransportOrdering; +use crate::CultNetTransportProfile; +use crate::CultNetTransportProtocol; +use crate::CultNetTransportStats; -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct CultNetRudpOptions { - pub wire_contract: CultNetWireContract, - pub max_datagram_bytes: usize, - pub retries: usize, - pub ack_timeout: Duration, +const RUDP_MAGIC: [u8; 4] = [0x43, 0x4e, 0x52, 0x30]; +const RUDP_VERSION: u8 = 0; +const RUDP_FIXED_HEADER_BYTES: usize = 36; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CultNetRudpPacketType { + Connect, + Accept, + Data, + Ack, + Ping, + Pong, + Disconnect, } -impl Default for CultNetRudpOptions { +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultNetRudpPacket { + pub packet_type: CultNetRudpPacketType, + pub connection_id: u32, + pub sequence: u32, + pub ack: u32, + pub ack_mask: u32, + pub channel_id: String, + pub reliable: bool, + pub ordered: bool, + pub sequenced: bool, + pub fragment_id: u16, + pub fragment_index: u16, + pub fragment_count: u16, + pub payload: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultNetRudpDeliveredFrame { + pub channel_id: String, + pub payload: Vec, + pub sequence: u32, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultNetRudpReceiveResult { + pub delivered: Vec, + pub reply: Option, + pub pong: bool, + pub pong_payload: Vec, + pub disconnected: bool, + pub disconnect_reason: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultNetRudpSessionOptions { + pub connection_id: u32, + pub initial_sequence: u32, + pub resend_delay_ms: u64, + pub max_pending_reliable_packets: Option, +} + +impl Default for CultNetRudpSessionOptions { fn default() -> Self { Self { - wire_contract: CultNetWireContract::CultNetSchemaV0, - max_datagram_bytes: DEFAULT_CULTNET_RUDP_MAX_DATAGRAM_BYTES, - retries: DEFAULT_CULTNET_RUDP_RETRIES, - ack_timeout: DEFAULT_CULTNET_RUDP_ACK_TIMEOUT, + connection_id: 0, + initial_sequence: 1, + resend_delay_ms: 250, + max_pending_reliable_packets: None, } } } -#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] -#[serde(tag = "packetType", rename_all = "camelCase")] -pub enum CultNetRudpPacket { - #[serde(rename = "cultnet.rudp.data.v0", rename_all = "camelCase")] - Data { - protocol_id: String, - transfer_id: String, - sequence: u64, - wire_contract: CultNetWireContract, - #[serde(with = "serde_bytes")] +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct CultNetRudpSendOptions { + pub reliable: bool, + pub ordered: bool, + pub sequenced: bool, + pub now_ms: u64, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +struct PendingReliablePacket { + packet: CultNetRudpPacket, + last_sent_at_ms: u64, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +struct PendingOrderedFrame { + frame: CultNetRudpDeliveredFrame, + next_sequence: u32, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +struct FragmentBuffer { + channel_id: String, + ordered: bool, + fragment_count: u16, + payloads: BTreeMap>, + sequences: BTreeMap, +} + +pub struct CultNetRudpSession { + connection_id: u32, + resend_delay_ms: u64, + max_pending_reliable_packets: Option, + next_sequence: u32, + next_fragment_id: u16, + connected: bool, + last_received_at_ms: Option, + highest_received_sequence: Option, + received_sequences: BTreeSet, + pending_reliable: BTreeMap, + ordered_next_sequence_by_channel: BTreeMap, + ordered_buffers: BTreeMap>, + fragment_buffers: BTreeMap<(String, u16), FragmentBuffer>, +} + +impl CultNetRudpSession { + pub fn new(options: CultNetRudpSessionOptions) -> Self { + Self { + connection_id: options.connection_id, + resend_delay_ms: options.resend_delay_ms, + max_pending_reliable_packets: options.max_pending_reliable_packets, + next_sequence: options.initial_sequence, + next_fragment_id: 1, + connected: false, + last_received_at_ms: None, + highest_received_sequence: None, + received_sequences: BTreeSet::new(), + pending_reliable: BTreeMap::new(), + ordered_next_sequence_by_channel: BTreeMap::new(), + ordered_buffers: BTreeMap::new(), + fragment_buffers: BTreeMap::new(), + } + } + + pub fn connection_id(&self) -> u32 { + self.connection_id + } + + pub fn resend_delay_ms(&self) -> u64 { + self.resend_delay_ms + } + + pub fn connected(&self) -> bool { + self.connected + } + + pub fn pending_reliable_sequences(&self) -> Vec { + self.pending_reliable.keys().copied().collect() + } + + pub fn last_received_at_ms(&self) -> Option { + self.last_received_at_ms + } + + pub fn create_connect(&mut self, now_ms: u64, payload: Vec) -> Result { + self.ensure_reliable_capacity(1)?; + let packet = self.create_packet( + CultNetRudpPacketType::Connect, + "control", + payload, + true, + true, + false, + ); + self.track_reliable(packet.clone(), now_ms); + Ok(packet) + } + + pub fn accept_connect( + &mut self, + packet: &CultNetRudpPacket, + now_ms: u64, payload: Vec, - }, - #[serde(rename = "cultnet.rudp.ack.v0", rename_all = "camelCase")] - Ack { - protocol_id: String, - transfer_id: String, - sequence: u64, - }, -} + ) -> Result { + self.require_connection(packet)?; + if packet.packet_type != CultNetRudpPacketType::Connect { + return Err(anyhow!( + "Expected RUDP connect packet, got {:?}", + packet.packet_type + )); + } -pub fn encode_cultnet_rudp_packet(packet: &CultNetRudpPacket) -> Result> { - Ok(rmp_serde::to_vec(packet)?) -} + self.ensure_reliable_capacity(1)?; + self.remember_received(packet.sequence); + self.connected = true; + let response = self.create_packet( + CultNetRudpPacketType::Accept, + "control", + payload, + true, + true, + false, + ); + self.track_reliable(response.clone(), now_ms); + Ok(response) + } -pub fn decode_cultnet_rudp_packet(bytes: &[u8]) -> Result { - let packet: CultNetRudpPacket = rmp_serde::from_slice(bytes)?; - match &packet { - CultNetRudpPacket::Data { protocol_id, .. } - | CultNetRudpPacket::Ack { protocol_id, .. } => { - if protocol_id != CULTNET_RUDP_PROTOCOL_ID { - return Err(anyhow!( - "unsupported CultNet RUDP protocol id: {protocol_id}" - )); + pub fn send( + &mut self, + channel_id: &str, + payload: Vec, + options: CultNetRudpSendOptions, + ) -> Result { + self.send_many(channel_id, payload, options, None)? + .into_iter() + .next() + .ok_or_else(|| anyhow!("RUDP send produced no packets")) + } + + pub fn send_many( + &mut self, + channel_id: &str, + payload: Vec, + options: CultNetRudpSendOptions, + max_fragment_bytes: Option, + ) -> Result> { + if !self.connected { + return Err(anyhow!( + "Cannot send RUDP data before the session is connected" + )); + } + + if let Some(max_fragment_bytes) = max_fragment_bytes { + if max_fragment_bytes == 0 { + return Err(anyhow!("RUDP max_fragment_bytes must be greater than zero")); + } + if payload.len() > max_fragment_bytes { + let fragment_count = payload.len().div_ceil(max_fragment_bytes); + if fragment_count > u16::MAX as usize { + return Err(anyhow!("RUDP payload requires more than 65535 fragments")); + } + self.ensure_reliable_capacity(if options.reliable { fragment_count } else { 0 })?; + let fragment_id = self.allocate_fragment_id(); + let mut packets = Vec::new(); + for index in 0..fragment_count { + let start = index * max_fragment_bytes; + let end = (start + max_fragment_bytes).min(payload.len()); + let packet = self.create_packet_with_fragments( + CultNetRudpPacketType::Data, + channel_id, + payload[start..end].to_vec(), + options.reliable, + options.ordered, + options.sequenced, + fragment_id, + index as u16, + fragment_count as u16, + ); + if packet.reliable { + self.track_reliable(packet.clone(), options.now_ms); + } + packets.push(packet); + } + return Ok(packets); + } + } + + self.ensure_reliable_capacity(if options.reliable { 1 } else { 0 })?; + let packet = self.create_packet( + CultNetRudpPacketType::Data, + channel_id, + payload, + options.reliable, + options.ordered, + options.sequenced, + ); + if packet.reliable { + self.track_reliable(packet.clone(), options.now_ms); + } + Ok(vec![packet]) + } + + pub fn receive( + &mut self, + packet: &CultNetRudpPacket, + now_ms: u64, + ) -> Result { + self.require_connection(packet)?; + self.apply_acknowledgements(packet); + self.last_received_at_ms = Some(now_ms); + let expected_sequence_if_uninitialized = self + .highest_received_sequence + .map(|sequence| sequence + 1) + .unwrap_or(packet.sequence); + + if packet.packet_type == CultNetRudpPacketType::Accept { + self.remember_received(packet.sequence); + self.connected = true; + return Ok(CultNetRudpReceiveResult { + delivered: Vec::new(), + reply: None, + pong: false, + pong_payload: Vec::new(), + disconnected: false, + disconnect_reason: Vec::new(), + }); + } + + if packet.packet_type == CultNetRudpPacketType::Ping { + self.remember_received(packet.sequence); + return Ok(CultNetRudpReceiveResult { + delivered: Vec::new(), + reply: Some(self.create_packet( + CultNetRudpPacketType::Pong, + "control", + packet.payload.clone(), + false, + false, + false, + )), + pong: false, + pong_payload: Vec::new(), + disconnected: false, + disconnect_reason: Vec::new(), + }); + } + + if packet.packet_type == CultNetRudpPacketType::Ack + || packet.packet_type == CultNetRudpPacketType::Pong + { + self.remember_received(packet.sequence); + return Ok(CultNetRudpReceiveResult { + delivered: Vec::new(), + reply: None, + pong: packet.packet_type == CultNetRudpPacketType::Pong, + pong_payload: if packet.packet_type == CultNetRudpPacketType::Pong { + packet.payload.clone() + } else { + Vec::new() + }, + disconnected: false, + disconnect_reason: Vec::new(), + }); + } + + if packet.packet_type == CultNetRudpPacketType::Disconnect { + self.remember_received(packet.sequence); + self.connected = false; + return Ok(CultNetRudpReceiveResult { + delivered: Vec::new(), + reply: None, + pong: false, + pong_payload: Vec::new(), + disconnected: true, + disconnect_reason: packet.payload.clone(), + }); + } + + if packet.packet_type != CultNetRudpPacketType::Data { + return Ok(CultNetRudpReceiveResult { + delivered: Vec::new(), + reply: None, + pong: false, + pong_payload: Vec::new(), + disconnected: false, + disconnect_reason: Vec::new(), + }); + } + + let duplicate = self.received_sequences.contains(&packet.sequence); + self.remember_received(packet.sequence); + if duplicate { + return Ok(CultNetRudpReceiveResult { + delivered: Vec::new(), + reply: None, + pong: false, + pong_payload: Vec::new(), + disconnected: false, + disconnect_reason: Vec::new(), + }); + } + + let Some((frame, ordered, next_sequence)) = self.reassemble(packet)? else { + return Ok(CultNetRudpReceiveResult { + delivered: Vec::new(), + reply: None, + pong: false, + pong_payload: Vec::new(), + disconnected: false, + disconnect_reason: Vec::new(), + }); + }; + let delivered = if ordered { + self.deliver_ordered(frame, next_sequence, expected_sequence_if_uninitialized) + } else { + vec![frame] + }; + Ok(CultNetRudpReceiveResult { + delivered, + reply: None, + pong: false, + pong_payload: Vec::new(), + disconnected: false, + disconnect_reason: Vec::new(), + }) + } + + pub fn create_ack(&mut self) -> CultNetRudpPacket { + self.create_packet( + CultNetRudpPacketType::Ack, + "control", + Vec::new(), + false, + false, + false, + ) + } + + pub fn create_ping(&mut self, payload: Vec) -> CultNetRudpPacket { + self.create_packet( + CultNetRudpPacketType::Ping, + "control", + payload, + false, + false, + false, + ) + } + + pub fn create_disconnect(&mut self, reason: Vec) -> CultNetRudpPacket { + self.connected = false; + self.create_packet( + CultNetRudpPacketType::Disconnect, + "control", + reason, + false, + false, + false, + ) + } + + pub fn check_timeout(&mut self, now_ms: u64, timeout_ms: u64) -> bool { + if !self.connected { + return false; + } + let Some(last_received_at_ms) = self.last_received_at_ms else { + return false; + }; + if now_ms.saturating_sub(last_received_at_ms) <= timeout_ms { + return false; + } + self.connected = false; + true + } + + pub fn due_resends(&mut self, now_ms: u64) -> Vec { + let mut due = Vec::new(); + for pending in self.pending_reliable.values_mut() { + if now_ms.saturating_sub(pending.last_sent_at_ms) >= self.resend_delay_ms { + pending.last_sent_at_ms = now_ms; + due.push(pending.packet.clone()); + } + } + due.sort_by_key(|packet| packet.sequence); + due + } + + fn create_packet( + &mut self, + packet_type: CultNetRudpPacketType, + channel_id: &str, + payload: Vec, + reliable: bool, + ordered: bool, + sequenced: bool, + ) -> CultNetRudpPacket { + self.create_packet_with_fragments( + packet_type, + channel_id, + payload, + reliable, + ordered, + sequenced, + 0, + 0, + 0, + ) + } + + #[allow(clippy::too_many_arguments)] + fn create_packet_with_fragments( + &mut self, + packet_type: CultNetRudpPacketType, + channel_id: &str, + payload: Vec, + reliable: bool, + ordered: bool, + sequenced: bool, + fragment_id: u16, + fragment_index: u16, + fragment_count: u16, + ) -> CultNetRudpPacket { + let sequence = self.next_sequence; + self.next_sequence = self + .next_sequence + .checked_add(1) + .expect("sequence overflow"); + let (ack, ack_mask) = self.ack_state(); + CultNetRudpPacket { + packet_type, + connection_id: self.connection_id, + sequence, + ack, + ack_mask, + channel_id: channel_id.to_string(), + reliable, + ordered, + sequenced, + fragment_id, + fragment_index, + fragment_count, + payload, + } + } + + fn track_reliable(&mut self, packet: CultNetRudpPacket, now_ms: u64) { + self.pending_reliable.insert( + packet.sequence, + PendingReliablePacket { + packet, + last_sent_at_ms: now_ms, + }, + ); + } + + fn ensure_reliable_capacity(&self, packet_count: usize) -> Result<()> { + if packet_count == 0 { + return Ok(()); + } + if let Some(limit) = self.max_pending_reliable_packets { + if self.pending_reliable.len() + packet_count > limit { + return Err(anyhow!("RUDP reliable send queue is full")); + } + } + Ok(()) + } + + fn apply_acknowledgements(&mut self, packet: &CultNetRudpPacket) { + self.pending_reliable.remove(&packet.ack); + for bit in 0..32 { + if (packet.ack_mask & (1_u32 << bit)) != 0 && packet.ack > bit { + self.pending_reliable.remove(&(packet.ack - bit - 1)); } } } - Ok(packet) -} -pub fn create_cultnet_rudp_data_packet( - transfer_id: impl Into, - sequence: u64, - message: &CultNetMessage, - wire_contract: CultNetWireContract, -) -> Result { - Ok(CultNetRudpPacket::Data { - protocol_id: CULTNET_RUDP_PROTOCOL_ID.to_string(), - transfer_id: transfer_id.into(), - sequence, - wire_contract, - payload: encode_cultnet_message_to_vec(message, wire_contract)?, - }) -} + fn remember_received(&mut self, sequence: u32) { + self.received_sequences.insert(sequence); + if self + .highest_received_sequence + .is_none_or(|highest| sequence > highest) + { + self.highest_received_sequence = Some(sequence); + } + } -pub fn create_cultnet_rudp_ack_packet( - transfer_id: impl Into, - sequence: u64, -) -> CultNetRudpPacket { - CultNetRudpPacket::Ack { - protocol_id: CULTNET_RUDP_PROTOCOL_ID.to_string(), - transfer_id: transfer_id.into(), - sequence, + fn ack_state(&self) -> (u32, u32) { + let ack = self.highest_received_sequence.unwrap_or(0); + let mut ack_mask = 0_u32; + for bit in 0..32 { + if ack > bit && self.received_sequences.contains(&(ack - bit - 1)) { + ack_mask |= 1_u32 << bit; + } + } + (ack, ack_mask) + } + + fn reassemble( + &mut self, + packet: &CultNetRudpPacket, + ) -> Result> { + if packet.fragment_count == 0 { + return Ok(Some(( + CultNetRudpDeliveredFrame { + channel_id: packet.channel_id.clone(), + payload: packet.payload.clone(), + sequence: packet.sequence, + }, + packet.ordered, + packet.sequence + 1, + ))); + } + if packet.fragment_id == 0 { + return Err(anyhow!( + "RUDP fragmented packet must have a non-zero fragment id" + )); + } + if packet.fragment_index >= packet.fragment_count { + return Err(anyhow!( + "RUDP fragment index must be lower than fragment count" + )); + } + + let key = (packet.channel_id.clone(), packet.fragment_id); + let buffer = self + .fragment_buffers + .entry(key.clone()) + .or_insert_with(|| FragmentBuffer { + channel_id: packet.channel_id.clone(), + ordered: packet.ordered, + fragment_count: packet.fragment_count, + payloads: BTreeMap::new(), + sequences: BTreeMap::new(), + }); + if buffer.fragment_count != packet.fragment_count || buffer.ordered != packet.ordered { + return Err(anyhow!( + "RUDP fragment metadata changed within a fragment set" + )); + } + buffer + .payloads + .insert(packet.fragment_index, packet.payload.clone()); + buffer + .sequences + .insert(packet.fragment_index, packet.sequence); + if buffer.payloads.len() < packet.fragment_count as usize { + return Ok(None); + } + + let mut payload = Vec::new(); + let mut sequences = Vec::new(); + for index in 0..packet.fragment_count { + let Some(chunk) = buffer.payloads.get(&index) else { + return Ok(None); + }; + let Some(sequence) = buffer.sequences.get(&index) else { + return Ok(None); + }; + payload.extend_from_slice(chunk); + sequences.push(*sequence); + } + let channel_id = buffer.channel_id.clone(); + let ordered = buffer.ordered; + self.fragment_buffers.remove(&key); + Ok(Some(( + CultNetRudpDeliveredFrame { + channel_id, + payload, + sequence: *sequences.iter().min().unwrap(), + }, + ordered, + sequences.iter().max().unwrap() + 1, + ))) + } + + fn deliver_ordered( + &mut self, + frame: CultNetRudpDeliveredFrame, + next_sequence_after_frame: u32, + expected_sequence_if_uninitialized: u32, + ) -> Vec { + let channel_id = frame.channel_id.clone(); + let next = if let Some(next) = self + .ordered_next_sequence_by_channel + .get(&channel_id) + .copied() + { + next + } else { + self.ordered_next_sequence_by_channel.insert( + channel_id.clone(), + expected_sequence_if_uninitialized.min(frame.sequence), + ); + expected_sequence_if_uninitialized.min(frame.sequence) + }; + + if frame.sequence < next { + return Vec::new(); + } + + if frame.sequence > next { + self.ordered_buffers.entry(channel_id).or_default().insert( + frame.sequence, + PendingOrderedFrame { + frame, + next_sequence: next_sequence_after_frame, + }, + ); + return Vec::new(); + } + + self.ordered_next_sequence_by_channel + .insert(channel_id.clone(), next_sequence_after_frame); + let mut delivered = vec![frame]; + delivered.extend(self.drain_ordered(&channel_id)); + delivered + } + + fn drain_ordered(&mut self, channel_id: &str) -> Vec { + let mut delivered = Vec::new(); + loop { + let Some(next) = self + .ordered_next_sequence_by_channel + .get(channel_id) + .copied() + else { + break; + }; + let Some(buffer) = self.ordered_buffers.get_mut(channel_id) else { + break; + }; + let Some(pending) = buffer.remove(&next) else { + break; + }; + delivered.push(pending.frame); + self.ordered_next_sequence_by_channel + .insert(channel_id.to_string(), pending.next_sequence); + } + delivered + } + + fn allocate_fragment_id(&mut self) -> u16 { + let fragment_id = self.next_fragment_id; + self.next_fragment_id = self.next_fragment_id.saturating_add(1); + if self.next_fragment_id == 0 { + self.next_fragment_id = 1; + } + fragment_id + } + + fn require_connection(&self, packet: &CultNetRudpPacket) -> Result<()> { + if packet.connection_id != self.connection_id { + return Err(anyhow!( + "RUDP packet connection id {} does not match {}", + packet.connection_id, + self.connection_id + )); + } + Ok(()) } } -pub fn send_cultnet_message_rudp( - socket: &UdpSocket, - target: SocketAddr, - message: &CultNetMessage, - options: &CultNetRudpOptions, -) -> Result { - let transfer_id = Uuid::new_v4().to_string(); - send_cultnet_message_rudp_with_transfer_id(socket, target, message, options, &transfer_id)?; - Ok(transfer_id) +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CultNetRudpSocketMode { + Client, + Server, } -pub fn send_cultnet_message_rudp_with_transfer_id( - socket: &UdpSocket, - target: SocketAddr, - message: &CultNetMessage, - options: &CultNetRudpOptions, - transfer_id: &str, -) -> Result<()> { - if options.retries == 0 { - return Err(anyhow!("CultNet RUDP retries must be greater than zero")); +pub struct CultNetRudpSocketTransportOptions { + pub runtime_id: String, + pub socket: UdpSocket, + pub mode: CultNetRudpSocketMode, + pub remote_addr: Option, + pub connection_id: u32, + pub initial_sequence: u32, + pub resend_delay_ms: u64, + pub transport_id: Option, + pub max_payload_bytes: Option, + pub max_fragment_bytes: Option, + pub max_pending_reliable_packets: Option, +} + +impl CultNetRudpSocketTransportOptions { + pub fn client( + runtime_id: impl Into, + socket: UdpSocket, + remote_addr: SocketAddr, + connection_id: u32, + ) -> Self { + Self { + runtime_id: runtime_id.into(), + socket, + mode: CultNetRudpSocketMode::Client, + remote_addr: Some(remote_addr), + connection_id, + initial_sequence: 1, + resend_delay_ms: 250, + transport_id: None, + max_payload_bytes: None, + max_fragment_bytes: None, + max_pending_reliable_packets: None, + } } - let data_packet = - create_cultnet_rudp_data_packet(transfer_id, 0, message, options.wire_contract)?; - let data_bytes = encode_cultnet_rudp_packet(&data_packet)?; - if data_bytes.len() > options.max_datagram_bytes { + pub fn server(runtime_id: impl Into, socket: UdpSocket, connection_id: u32) -> Self { + Self { + runtime_id: runtime_id.into(), + socket, + mode: CultNetRudpSocketMode::Server, + remote_addr: None, + connection_id, + initial_sequence: 1, + resend_delay_ms: 250, + transport_id: None, + max_payload_bytes: None, + max_fragment_bytes: None, + max_pending_reliable_packets: None, + } + } +} + +pub struct CultNetRudpSocketTransportConnection { + socket: UdpSocket, + session: CultNetRudpSession, + mode: CultNetRudpSocketMode, + remote_addr: Option, + pub profile: CultNetTransportProfile, + stats: CultNetTransportStats, + delivered_frames: VecDeque, + max_fragment_bytes: Option, + disconnect_reason: Option>, + pong_payloads: VecDeque>, +} + +impl CultNetRudpSocketTransportConnection { + pub fn new(options: CultNetRudpSocketTransportOptions) -> Result { + let local_addr = options.socket.local_addr()?; + let profile = create_rudp_transport_profile( + options.runtime_id, + RudpTransportProfileOptions { + transport_id: options.transport_id, + host: Some(local_addr.ip().to_string()), + port: Some(local_addr.port()), + max_payload_bytes: options.max_payload_bytes, + max_fragment_bytes: options.max_fragment_bytes, + max_pending_reliable_packets: options.max_pending_reliable_packets, + }, + ); + let max_pending_reliable_packets = options + .max_pending_reliable_packets + .map(|value| value as usize); + Ok(Self { + socket: options.socket, + session: CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: options.connection_id, + initial_sequence: options.initial_sequence, + resend_delay_ms: options.resend_delay_ms, + max_pending_reliable_packets, + }), + mode: options.mode, + remote_addr: options.remote_addr, + profile, + stats: CultNetTransportStats::default(), + delivered_frames: VecDeque::new(), + max_fragment_bytes: options.max_fragment_bytes.map(|value| value as usize), + disconnect_reason: None, + pong_payloads: VecDeque::new(), + }) + } + + pub fn connected(&self) -> bool { + self.session.connected() + } + + pub fn stats(&self) -> CultNetTransportStats { + self.stats.clone() + } + + pub fn disconnect_reason(&self) -> Option<&[u8]> { + self.disconnect_reason.as_deref() + } + + pub fn pop_pong_payload(&mut self) -> Option> { + self.pong_payloads.pop_front() + } + + pub fn connect(&mut self, payload: Vec) -> Result<()> { + if self.mode != CultNetRudpSocketMode::Client { + return Err(anyhow!( + "Only a client RUDP socket transport can initiate connect" + )); + } + let packet = self.session.create_connect(now_ms(), payload)?; + self.send_packet(&packet) + } + + pub fn send(&mut self, channel_id: &str, payload: Vec) -> Result<()> { + let options = channel_send_options(channel_id, now_ms()); + let packets = + self.session + .send_many(channel_id, payload, options, self.max_fragment_bytes)?; + for packet in packets { + self.send_packet(&packet)?; + } + self.stats.frames_sent += 1; + Ok(()) + } + + pub fn disconnect(&mut self, reason: Vec) -> Result<()> { + let packet = self.session.create_disconnect(reason); + self.send_packet(&packet) + } + + pub fn ping(&mut self, payload: Vec) -> Result<()> { + let packet = self.session.create_ping(payload); + self.send_packet(&packet) + } + + pub fn check_timeout(&mut self, timeout_ms: u64) -> bool { + self.session.check_timeout(now_ms(), timeout_ms) + } + + pub fn receive_once(&mut self) -> Result> { + if let Some(frame) = self.delivered_frames.pop_front() { + return Ok(Some(frame)); + } + + let mut wire = vec![0_u8; 65_535]; + let (received, remote_addr) = match self.socket.recv_from(&mut wire) { + Ok(value) => value, + Err(error) + if error.kind() == ErrorKind::WouldBlock || error.kind() == ErrorKind::TimedOut => + { + return Ok(None); + } + Err(error) => return Err(error.into()), + }; + wire.truncate(received); + self.stats.bytes_received += received as u64; + + if let Some(expected) = self.remote_addr { + if expected != remote_addr { + return Ok(None); + } + } else { + self.remote_addr = Some(remote_addr); + } + + let packet = decode_rudp_packet(&wire)?; + if self.mode == CultNetRudpSocketMode::Server + && packet.packet_type == CultNetRudpPacketType::Connect + { + let accept = self.session.accept_connect(&packet, now_ms(), Vec::new())?; + self.send_packet(&accept)?; + return Ok(None); + } + + let result = self.session.receive(&packet, now_ms())?; + if let Some(reply) = result.reply { + self.send_packet(&reply)?; + } + if result.pong { + self.pong_payloads.push_back(result.pong_payload); + } + if result.disconnected { + self.disconnect_reason = Some(result.disconnect_reason); + return Ok(None); + } + + for frame in result.delivered { + self.delivered_frames.push_back(CultNetTransportFrame { + channel_id: frame.channel_id, + payload: frame.payload, + }); + self.stats.frames_received += 1; + } + let frame = self.delivered_frames.pop_front(); + if packet.packet_type == CultNetRudpPacketType::Accept || frame.is_some() { + let ack = self.session.create_ack(); + self.send_packet(&ack)?; + } + Ok(frame) + } + + pub fn poll_resends(&mut self) -> Result<()> { + for packet in self.session.due_resends(now_ms()) { + self.send_packet(&packet)?; + } + Ok(()) + } + + fn send_packet(&mut self, packet: &CultNetRudpPacket) -> Result<()> { + let Some(remote_addr) = self.remote_addr else { + return Err(anyhow!( + "RUDP socket transport does not have a remote endpoint" + )); + }; + let wire = encode_rudp_packet(packet)?; + let sent = self.socket.send_to(&wire, remote_addr)?; + self.stats.bytes_sent += sent as u64; + Ok(()) + } +} + +#[derive(Clone, Debug, Default)] +pub struct RudpTransportProfileOptions { + pub transport_id: Option, + pub host: Option, + pub port: Option, + pub max_payload_bytes: Option, + pub max_fragment_bytes: Option, + pub max_pending_reliable_packets: Option, +} + +pub fn create_rudp_transport_profile( + runtime_id: impl Into, + options: RudpTransportProfileOptions, +) -> CultNetTransportProfile { + CultNetTransportProfile { + schema_version: "cultnet.transport_profile.v0".to_string(), + runtime_id: runtime_id.into(), + transports: vec![CultNetTransportDescriptor { + transport_id: options.transport_id.unwrap_or_else(|| "rudp".to_string()), + protocol: CultNetTransportProtocol::Rudp, + host: options.host, + port: options.port, + path: None, + discovery_group: None, + wire_contracts: Some(vec!["cultnet.schema.v0".to_string()]), + channels: vec![ + CultNetTransportChannel { + channel_id: "schema".to_string(), + delivery: CultNetTransportDelivery::Reliable, + ordering: CultNetTransportOrdering::Ordered, + max_payload_bytes: options.max_payload_bytes, + max_fragment_bytes: options.max_fragment_bytes, + max_pending_reliable_packets: options.max_pending_reliable_packets, + }, + CultNetTransportChannel { + channel_id: "latest".to_string(), + delivery: CultNetTransportDelivery::Unreliable, + ordering: CultNetTransportOrdering::Sequenced, + max_payload_bytes: options.max_payload_bytes, + max_fragment_bytes: options.max_fragment_bytes, + max_pending_reliable_packets: options.max_pending_reliable_packets, + }, + CultNetTransportChannel { + channel_id: "realtime".to_string(), + delivery: CultNetTransportDelivery::Unreliable, + ordering: CultNetTransportOrdering::Unordered, + max_payload_bytes: options.max_payload_bytes, + max_fragment_bytes: options.max_fragment_bytes, + max_pending_reliable_packets: options.max_pending_reliable_packets, + }, + ], + }], + } +} + +pub fn encode_rudp_packet(packet: &CultNetRudpPacket) -> Result> { + let channel_id = packet.channel_id.as_bytes(); + if channel_id.len() > u8::MAX as usize { return Err(anyhow!( - "CultNet RUDP packet is {} bytes, exceeding max datagram size {}", - data_bytes.len(), - options.max_datagram_bytes + "CultNet RUDP channel id cannot exceed 255 UTF-8 bytes" )); } - let previous_timeout = socket.read_timeout()?; - socket.set_read_timeout(Some(options.ack_timeout))?; - let mut buffer = vec![0_u8; options.max_datagram_bytes]; - let mut last_error = None; + let header_bytes = RUDP_FIXED_HEADER_BYTES + channel_id.len(); + let mut wire = vec![0_u8; header_bytes + packet.payload.len()]; + wire[..4].copy_from_slice(&RUDP_MAGIC); + wire[4] = RUDP_VERSION; + wire[5] = packet_type_to_code(packet.packet_type); + wire[6] = encode_flags(packet); + wire[7] = header_bytes as u8; + wire[8..12].copy_from_slice(&packet.connection_id.to_be_bytes()); + wire[12..16].copy_from_slice(&packet.sequence.to_be_bytes()); + wire[16..20].copy_from_slice(&packet.ack.to_be_bytes()); + wire[20..24].copy_from_slice(&packet.ack_mask.to_be_bytes()); + wire[24..26].copy_from_slice(&packet.fragment_id.to_be_bytes()); + wire[26..28].copy_from_slice(&packet.fragment_index.to_be_bytes()); + wire[28..30].copy_from_slice(&packet.fragment_count.to_be_bytes()); + wire[30..34].copy_from_slice(&(packet.payload.len() as u32).to_be_bytes()); + wire[34] = channel_id.len() as u8; + wire[35] = 0; + wire[RUDP_FIXED_HEADER_BYTES..header_bytes].copy_from_slice(channel_id); + wire[header_bytes..].copy_from_slice(&packet.payload); + Ok(wire) +} - for _ in 0..options.retries { - socket.send_to(&data_bytes, target)?; - match socket.recv_from(&mut buffer) { - Ok((size, source)) if source == target => { - match decode_cultnet_rudp_packet(&buffer[..size]) { - Ok(CultNetRudpPacket::Ack { - transfer_id: ack_transfer_id, - sequence, - .. - }) if ack_transfer_id == transfer_id && sequence == 0 => { - socket.set_read_timeout(previous_timeout)?; - return Ok(()); - } - Ok(_) => {} - Err(error) => last_error = Some(error), - } - } - Ok(_) => {} - Err(error) - if matches!( - error.kind(), - std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut - ) => {} - Err(error) => { - socket.set_read_timeout(previous_timeout)?; - return Err(error.into()); - } - } +pub fn decode_rudp_packet(wire: &[u8]) -> Result { + if wire.len() < RUDP_FIXED_HEADER_BYTES { + return Err(anyhow!( + "CultNet RUDP packet is shorter than the fixed header" + )); + } + if wire[..4] != RUDP_MAGIC { + return Err(anyhow!("CultNet RUDP packet has the wrong magic")); + } + if wire[4] != RUDP_VERSION { + return Err(anyhow!( + "Unsupported CultNet RUDP packet version {}", + wire[4] + )); } - socket.set_read_timeout(previous_timeout)?; - match last_error { - Some(error) => Err(anyhow!("CultNet RUDP acknowledgement failed: {error}")), - None => Err(anyhow!( - "CultNet RUDP acknowledgement timed out for transfer {transfer_id}" - )), + let packet_type = packet_type_from_code(wire[5])?; + let header_bytes = wire[7] as usize; + let channel_id_len = wire[34] as usize; + if header_bytes != RUDP_FIXED_HEADER_BYTES + channel_id_len { + return Err(anyhow!( + "CultNet RUDP packet header length does not match the channel id length" + )); + } + let payload_len = u32::from_be_bytes(wire[30..34].try_into()?) as usize; + if wire.len() != header_bytes + payload_len { + return Err(anyhow!( + "CultNet RUDP packet payload length does not match the packet size" + )); + } + + let flags = wire[6]; + Ok(CultNetRudpPacket { + packet_type, + reliable: (flags & 0b0000_0001) != 0, + ordered: (flags & 0b0000_0010) != 0, + sequenced: (flags & 0b0000_0100) != 0, + connection_id: u32::from_be_bytes(wire[8..12].try_into()?), + sequence: u32::from_be_bytes(wire[12..16].try_into()?), + ack: u32::from_be_bytes(wire[16..20].try_into()?), + ack_mask: u32::from_be_bytes(wire[20..24].try_into()?), + fragment_id: u16::from_be_bytes(wire[24..26].try_into()?), + fragment_index: u16::from_be_bytes(wire[26..28].try_into()?), + fragment_count: u16::from_be_bytes(wire[28..30].try_into()?), + channel_id: String::from_utf8(wire[RUDP_FIXED_HEADER_BYTES..header_bytes].to_vec())?, + payload: wire[header_bytes..].to_vec(), + }) +} + +fn encode_flags(packet: &CultNetRudpPacket) -> u8 { + (if packet.reliable { 0b0000_0001 } else { 0 }) + | (if packet.ordered { 0b0000_0010 } else { 0 }) + | (if packet.sequenced { 0b0000_0100 } else { 0 }) + | (if packet.fragment_count > 0 { + 0b0000_1000 + } else { + 0 + }) +} + +fn packet_type_to_code(packet_type: CultNetRudpPacketType) -> u8 { + match packet_type { + CultNetRudpPacketType::Connect => 1, + CultNetRudpPacketType::Accept => 2, + CultNetRudpPacketType::Data => 3, + CultNetRudpPacketType::Ack => 4, + CultNetRudpPacketType::Ping => 5, + CultNetRudpPacketType::Pong => 6, + CultNetRudpPacketType::Disconnect => 7, } } -pub fn recv_cultnet_message_rudp( - socket: &UdpSocket, - options: &CultNetRudpOptions, -) -> Result<(CultNetMessage, SocketAddr, String)> { - let mut buffer = vec![0_u8; options.max_datagram_bytes]; - loop { - let (size, source) = match socket.recv_from(&mut buffer) { - Ok(received) => received, - Err(error) if error.kind() == ErrorKind::ConnectionReset => continue, - Err(error) => return Err(error.into()), - }; - let packet = decode_cultnet_rudp_packet(&buffer[..size])?; - let CultNetRudpPacket::Data { - transfer_id, - sequence, - wire_contract, - payload, - .. - } = packet - else { - continue; - }; - let message = decode_cultnet_message_from_slice(&payload, wire_contract)?; - let ack = create_cultnet_rudp_ack_packet(transfer_id.clone(), sequence); - let ack_bytes = encode_cultnet_rudp_packet(&ack)?; - socket.send_to(&ack_bytes, source)?; - return Ok((message, source, transfer_id)); +fn channel_send_options(channel_id: &str, now_ms: u64) -> CultNetRudpSendOptions { + match channel_id { + "schema" => CultNetRudpSendOptions { + reliable: true, + ordered: true, + sequenced: false, + now_ms, + }, + "latest" => CultNetRudpSendOptions { + reliable: false, + ordered: false, + sequenced: true, + now_ms, + }, + _ => CultNetRudpSendOptions { + reliable: false, + ordered: false, + sequenced: false, + now_ms, + }, } } -#[cfg(test)] -mod tests { - use super::*; +fn now_ms() -> u64 { + SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|duration| duration.as_millis() as u64) + .unwrap_or(0) +} - fn hello_message(runtime_id: &str) -> CultNetMessage { - CultNetMessage::Hello { - runtime_id: runtime_id.to_string(), - runtime_kind: "test".to_string(), - agent_id: None, - role: None, - display_name: None, - supported_document_types: None, - supported_mutation_contracts: None, - supported_message_versions: None, - supports_schema_catalog: Some(true), - } - } - - #[test] - fn rudp_packet_round_trips_cultnet_message() -> Result<()> { - let message = hello_message("sender"); - let packet = create_cultnet_rudp_data_packet( - "transfer-1", - 0, - &message, - CultNetWireContract::CultNetSchemaV0, - )?; - let encoded = encode_cultnet_rudp_packet(&packet)?; - let decoded = decode_cultnet_rudp_packet(&encoded)?; - - let CultNetRudpPacket::Data { - payload, - wire_contract, - .. - } = decoded - else { - return Err(anyhow!("expected data packet")); - }; - assert_eq!( - decode_cultnet_message_from_slice(&payload, wire_contract)?, - message - ); - Ok(()) - } - - #[test] - fn rudp_socket_send_receives_acknowledged_message() -> Result<()> { - let sender = UdpSocket::bind("127.0.0.1:0")?; - let receiver = UdpSocket::bind("127.0.0.1:0")?; - let receiver_addr = receiver.local_addr()?; - let options = CultNetRudpOptions { - ack_timeout: Duration::from_millis(100), - retries: 3, - ..CultNetRudpOptions::default() - }; - let receiver_options = options.clone(); - - let handle = std::thread::spawn(move || -> Result<(CultNetMessage, String)> { - let (message, _source, transfer_id) = - recv_cultnet_message_rudp(&receiver, &receiver_options)?; - Ok((message, transfer_id)) - }); - - let message = hello_message("sender"); - let transfer_id = send_cultnet_message_rudp(&sender, receiver_addr, &message, &options)?; - let (received, received_transfer_id) = handle.join().expect("receiver thread panicked")?; - - assert_eq!(received, message); - assert_eq!(received_transfer_id, transfer_id); - Ok(()) - } - - #[test] - fn rudp_sender_retries_until_ack_arrives() -> Result<()> { - let sender = UdpSocket::bind("127.0.0.1:0")?; - let receiver = UdpSocket::bind("127.0.0.1:0")?; - let receiver_addr = receiver.local_addr()?; - let options = CultNetRudpOptions { - ack_timeout: Duration::from_millis(50), - retries: 3, - ..CultNetRudpOptions::default() - }; - - let handle = std::thread::spawn(move || -> Result<()> { - let mut buffer = [0_u8; DEFAULT_CULTNET_RUDP_MAX_DATAGRAM_BYTES]; - let (_first_size, _source) = receiver.recv_from(&mut buffer)?; - let (second_size, source) = receiver.recv_from(&mut buffer)?; - let CultNetRudpPacket::Data { - transfer_id, - sequence, - .. - } = decode_cultnet_rudp_packet(&buffer[..second_size])? - else { - return Err(anyhow!("expected retried data packet")); - }; - let ack = create_cultnet_rudp_ack_packet(transfer_id, sequence); - receiver.send_to(&encode_cultnet_rudp_packet(&ack)?, source)?; - Ok(()) - }); - - send_cultnet_message_rudp(&sender, receiver_addr, &hello_message("sender"), &options)?; - handle.join().expect("receiver thread panicked")?; - Ok(()) +fn packet_type_from_code(code: u8) -> Result { + match code { + 1 => Ok(CultNetRudpPacketType::Connect), + 2 => Ok(CultNetRudpPacketType::Accept), + 3 => Ok(CultNetRudpPacketType::Data), + 4 => Ok(CultNetRudpPacketType::Ack), + 5 => Ok(CultNetRudpPacketType::Ping), + 6 => Ok(CultNetRudpPacketType::Pong), + 7 => Ok(CultNetRudpPacketType::Disconnect), + _ => Err(anyhow!("Unsupported CultNet RUDP packet type {code}")), } } diff --git a/vendor/cultnet-rs/src/schema_discovery.rs b/vendor/cultnet-rs/src/schema_discovery.rs index 15ea9fb..2cc1420 100644 --- a/vendor/cultnet-rs/src/schema_discovery.rs +++ b/vendor/cultnet-rs/src/schema_discovery.rs @@ -207,6 +207,13 @@ pub fn builtin_schema_registry() -> Result { None, None, )?, + schema_registration( + include_str!("../contracts/cultnet.transport-profile.schema.json"), + CultNetSchemaKind::SharedContract, + vec![CultNetWireContract::CultNetSchemaV0], + Some("cultnet.transport_profile.v0"), + None, + )?, schema_registration( include_str!("../contracts/cultnet.login.schema.json"), CultNetSchemaKind::WireMessage, diff --git a/vendor/cultnet-rs/src/transport.rs b/vendor/cultnet-rs/src/transport.rs new file mode 100644 index 0000000..54f4608 --- /dev/null +++ b/vendor/cultnet-rs/src/transport.rs @@ -0,0 +1,192 @@ +use anyhow::Result; +use anyhow::anyhow; +use serde::Deserialize; +use serde::Serialize; +use std::io::Read; +use std::io::Write; + +use crate::CultNetTransportChannel; +use crate::CultNetTransportDelivery; +use crate::CultNetTransportDescriptor; +use crate::CultNetTransportOrdering; +use crate::CultNetTransportProfile; +use crate::CultNetTransportProtocol; +use crate::FRAME_HEADER_BYTES; +use crate::encode_frame; + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct CultNetTransportStats { + pub bytes_received: u64, + pub bytes_sent: u64, + pub frames_received: u64, + pub frames_sent: u64, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultNetTransportFrame { + pub channel_id: String, + pub payload: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct CultNetReconnectPolicy { + pub schema_version: String, + pub policy_id: String, + pub base_delay_ms: u64, + pub max_delay_ms: u64, + pub max_jitter_ms: u64, + #[serde(skip_serializing_if = "Option::is_none")] + pub max_attempts: Option, +} + +#[derive(Clone, Debug)] +pub struct CultNetReconnectPolicyOptions { + pub policy_id: String, + pub base_delay_ms: u64, + pub max_delay_ms: u64, + pub max_jitter_ms: u64, + pub max_attempts: Option, +} + +impl Default for CultNetReconnectPolicyOptions { + fn default() -> Self { + Self { + policy_id: "default".to_string(), + base_delay_ms: 1_000, + max_delay_ms: 30_000, + max_jitter_ms: 250, + max_attempts: None, + } + } +} + +pub fn create_reconnect_policy(options: CultNetReconnectPolicyOptions) -> CultNetReconnectPolicy { + CultNetReconnectPolicy { + schema_version: "cultnet.reconnect_policy.v0".to_string(), + policy_id: if options.policy_id.trim().is_empty() { + "default".to_string() + } else { + options.policy_id + }, + base_delay_ms: options.base_delay_ms, + max_delay_ms: options.max_delay_ms, + max_jitter_ms: options.max_jitter_ms, + max_attempts: options.max_attempts, + } +} + +pub fn compute_reconnect_delay_ms( + policy: &CultNetReconnectPolicy, + attempt: u32, + jitter_ms: u64, +) -> u64 { + let normalized_attempt = attempt.max(1); + let multiplier = 2_u64.saturating_pow(normalized_attempt.saturating_sub(1)); + let capped_base_delay = policy + .base_delay_ms + .saturating_mul(multiplier) + .min(policy.max_delay_ms); + capped_base_delay + jitter_ms.min(policy.max_jitter_ms) +} + +#[derive(Clone, Debug, Default)] +pub struct TcpFramedTransportProfileOptions { + pub transport_id: Option, + pub host: Option, + pub port: Option, + pub max_payload_bytes: Option, + pub max_fragment_bytes: Option, +} + +pub fn create_tcp_framed_transport_profile( + runtime_id: impl Into, + options: TcpFramedTransportProfileOptions, +) -> CultNetTransportProfile { + CultNetTransportProfile { + schema_version: "cultnet.transport_profile.v0".to_string(), + runtime_id: runtime_id.into(), + transports: vec![CultNetTransportDescriptor { + transport_id: options + .transport_id + .unwrap_or_else(|| "tcp-framed".to_string()), + protocol: CultNetTransportProtocol::TcpFramed, + host: options.host, + port: options.port, + path: None, + discovery_group: None, + wire_contracts: Some(vec!["cultnet.schema.v0".to_string()]), + channels: vec![CultNetTransportChannel { + channel_id: "schema".to_string(), + delivery: CultNetTransportDelivery::Reliable, + ordering: CultNetTransportOrdering::Ordered, + max_payload_bytes: options.max_payload_bytes, + max_fragment_bytes: options.max_fragment_bytes, + max_pending_reliable_packets: None, + }], + }], + } +} + +pub struct TcpFramedTransportConnection { + stream: TStream, + pub profile: CultNetTransportProfile, + stats: CultNetTransportStats, +} + +impl TcpFramedTransportConnection { + pub fn new(stream: TStream, profile: CultNetTransportProfile) -> Self { + Self { + stream, + profile, + stats: CultNetTransportStats::default(), + } + } + + pub fn stats(&self) -> CultNetTransportStats { + self.stats.clone() + } + + pub fn into_inner(self) -> TStream { + self.stream + } +} + +impl TcpFramedTransportConnection +where + TStream: Write, +{ + pub fn send(&mut self, channel_id: &str, payload: &[u8]) -> Result<()> { + if channel_id != "schema" { + return Err(anyhow!( + "tcp_framed transport only supports the schema channel, got {channel_id:?}" + )); + } + + let frame = encode_frame(payload)?; + self.stream.write_all(&frame)?; + self.stream.flush()?; + self.stats.bytes_sent += frame.len() as u64; + self.stats.frames_sent += 1; + Ok(()) + } +} + +impl TcpFramedTransportConnection +where + TStream: Read, +{ + pub fn receive(&mut self) -> Result { + let mut header = [0_u8; FRAME_HEADER_BYTES]; + self.stream.read_exact(&mut header)?; + let payload_len = u32::from_be_bytes(header) as usize; + let mut payload = vec![0_u8; payload_len]; + self.stream.read_exact(&mut payload)?; + self.stats.bytes_received += (FRAME_HEADER_BYTES + payload_len) as u64; + self.stats.frames_received += 1; + Ok(CultNetTransportFrame { + channel_id: "schema".to_string(), + payload, + }) + } +} diff --git a/vendor/cultnet-rs/tests/cultnet.rs b/vendor/cultnet-rs/tests/cultnet.rs index 83112ff..73adf4d 100644 --- a/vendor/cultnet-rs/tests/cultnet.rs +++ b/vendor/cultnet-rs/tests/cultnet.rs @@ -11,22 +11,80 @@ use cultnet_rs::CultNetDocumentPutOptions; use cultnet_rs::CultNetDocumentRegistry; use cultnet_rs::CultNetMessage; use cultnet_rs::CultNetMutationAuthority; +use cultnet_rs::CultNetRudpPacket; +use cultnet_rs::CultNetRudpPacketType; +use cultnet_rs::CultNetRudpSendOptions; +use cultnet_rs::CultNetRudpSession; +use cultnet_rs::CultNetRudpSessionOptions; +use cultnet_rs::CultNetRudpSocketMode; +use cultnet_rs::CultNetRudpSocketTransportConnection; +use cultnet_rs::CultNetRudpSocketTransportOptions; use cultnet_rs::CultNetSchemaKind; use cultnet_rs::CultNetSchemaRegistry; use cultnet_rs::CultNetSecret; use cultnet_rs::CultNetServerSecurityOptions; +use cultnet_rs::CultNetTransportChannel; +use cultnet_rs::CultNetTransportDelivery; +use cultnet_rs::CultNetTransportDescriptor; +use cultnet_rs::CultNetTransportFrame; +use cultnet_rs::CultNetTransportOrdering; +use cultnet_rs::CultNetTransportProfile; +use cultnet_rs::CultNetTransportProtocol; use cultnet_rs::CultNetWireContract; use cultnet_rs::LengthPrefixedMessageFramer; +use cultnet_rs::TcpFramedTransportConnection; +use cultnet_rs::TcpFramedTransportProfileOptions; use cultnet_rs::builtin_schema_registry; +use cultnet_rs::create_rudp_transport_profile; +use cultnet_rs::create_tcp_framed_transport_profile; use cultnet_rs::decode_cultnet_message_from_slice; +use cultnet_rs::decode_rudp_packet; use cultnet_rs::encode_cultnet_message_for_wire; use cultnet_rs::encode_cultnet_message_to_vec; use cultnet_rs::encode_frame; +use cultnet_rs::encode_rudp_packet; use pretty_assertions::assert_eq; +use std::net::UdpSocket; +use std::thread; +use std::time::Duration as StdDuration; const TS_HELLO_FRAME: &[u8] = include_bytes!("fixtures/cultnet-ts-hello.frame"); const TS_LEGACY_LOGIN_FRAME: &[u8] = include_bytes!("fixtures/cultnet-ts-legacy-login.frame"); +fn bind_udp_socket() -> Result { + let socket = UdpSocket::bind("127.0.0.1:0")?; + socket.set_read_timeout(Some(StdDuration::from_millis(20)))?; + Ok(socket) +} + +fn pump_rudp_handshake( + client: &mut CultNetRudpSocketTransportConnection, + server: &mut CultNetRudpSocketTransportConnection, +) -> Result<()> { + for _ in 0..20 { + let _ = server.receive_once()?; + let _ = client.receive_once()?; + let _ = server.receive_once()?; + if client.connected() && server.connected() { + return Ok(()); + } + thread::sleep(StdDuration::from_millis(5)); + } + anyhow::bail!("RUDP socket handshake did not complete"); +} + +fn receive_rudp_frame( + transport: &mut CultNetRudpSocketTransportConnection, +) -> Result { + for _ in 0..20 { + if let Some(frame) = transport.receive_once()? { + return Ok(frame); + } + thread::sleep(StdDuration::from_millis(5)); + } + anyhow::bail!("RUDP socket frame was not delivered") +} + #[derive(Clone, Debug, PartialEq, DatabaseEntry)] #[cultcache( type = "ghostlight.agent-state", @@ -84,11 +142,32 @@ fn cultnet_schema_messages_round_trip_through_messagepack_frames() -> Result<()> intent_document_types: Some(vec!["ghostlight.agent-state.intent.v0".to_string()]), receipt_document_types: Some(vec!["ghostlight.agent-state.receipt.v0".to_string()]), notes: Some(vec![ - "Face may request bounded memory mutation; coordinator reviews authority." + "Persona may request bounded memory mutation; coordinator reviews authority." .to_string(), ]), }]), supported_message_versions: None, + transport_profiles: Some(vec![CultNetTransportProfile { + schema_version: "cultnet.transport_profile.v0".to_string(), + runtime_id: "voidbot-main".to_string(), + transports: vec![CultNetTransportDescriptor { + transport_id: "direct-pipe".to_string(), + protocol: CultNetTransportProtocol::TcpFramed, + host: None, + port: None, + path: None, + discovery_group: None, + wire_contracts: Some(vec!["cultnet.schema.v0".to_string()]), + channels: vec![CultNetTransportChannel { + channel_id: "schema".to_string(), + delivery: CultNetTransportDelivery::Reliable, + ordering: CultNetTransportOrdering::Ordered, + max_payload_bytes: None, + max_fragment_bytes: None, + max_pending_reliable_packets: None, + }], + }], + }]), supports_schema_catalog: Some(true), }; let payload = encode_cultnet_message_to_vec(&message, CultNetWireContract::CultNetSchemaV0)?; @@ -105,6 +184,732 @@ fn cultnet_schema_messages_round_trip_through_messagepack_frames() -> Result<()> Ok(()) } +#[test] +fn tcp_framed_transport_carries_schema_payloads_with_stats() -> Result<()> { + let payload = b"cultnet-payload".to_vec(); + let profile = create_tcp_framed_transport_profile( + "rust-transport", + TcpFramedTransportProfileOptions { + transport_id: Some("test-tcp".to_string()), + ..TcpFramedTransportProfileOptions::default() + }, + ); + let mut sender = TcpFramedTransportConnection::new(Vec::::new(), profile.clone()); + sender.send("schema", &payload)?; + assert_eq!(sender.stats().frames_sent, 1); + assert_eq!(sender.stats().bytes_sent, (payload.len() + 4) as u64); + assert!(sender.send("unreliable", &[]).is_err()); + + let bytes = sender.into_inner(); + let mut receiver = TcpFramedTransportConnection::new(std::io::Cursor::new(bytes), profile); + let frame = receiver.receive()?; + assert_eq!(frame.channel_id, "schema"); + assert_eq!(frame.payload, payload); + assert_eq!(receiver.stats().frames_received, 1); + assert_eq!( + receiver.stats().bytes_received, + (frame.payload.len() + 4) as u64 + ); + assert_eq!( + receiver.profile.transports[0].protocol, + CultNetTransportProtocol::TcpFramed + ); + Ok(()) +} + +#[test] +fn rudp_packet_codec_uses_deterministic_reliable_ordered_fixture() -> Result<()> { + let encoded = encode_rudp_packet(&CultNetRudpPacket { + packet_type: CultNetRudpPacketType::Data, + connection_id: 0x01020304, + sequence: 0x0000002a, + ack: 0x00000029, + ack_mask: 0x80000001, + channel_id: "schema".to_string(), + reliable: true, + ordered: true, + sequenced: false, + fragment_id: 7, + fragment_index: 1, + fragment_count: 3, + payload: b"hello".to_vec(), + })?; + + assert_eq!( + encoded, + vec![ + 67, 78, 82, 48, 0, 3, 11, 42, 1, 2, 3, 4, 0, 0, 0, 42, 0, 0, 0, 41, 128, 0, 0, 1, 0, 7, + 0, 1, 0, 3, 0, 0, 0, 5, 6, 0, 115, 99, 104, 101, 109, 97, 104, 101, 108, 108, 111, + ] + ); + + let decoded = decode_rudp_packet(&encoded)?; + assert_eq!(decoded.packet_type, CultNetRudpPacketType::Data); + assert_eq!(decoded.connection_id, 0x01020304); + assert_eq!(decoded.sequence, 0x0000002a); + assert_eq!(decoded.ack, 0x00000029); + assert_eq!(decoded.ack_mask, 0x80000001); + assert_eq!(decoded.channel_id, "schema"); + assert!(decoded.reliable); + assert!(decoded.ordered); + assert!(!decoded.sequenced); + assert_eq!(decoded.fragment_id, 7); + assert_eq!(decoded.fragment_index, 1); + assert_eq!(decoded.fragment_count, 3); + assert_eq!(decoded.payload, b"hello"); + Ok(()) +} + +#[test] +fn rudp_transport_profile_advertises_state_and_realtime_channels() { + let profile = create_rudp_transport_profile( + "rust-rudp", + cultnet_rs::RudpTransportProfileOptions { + transport_id: Some("public-rudp".to_string()), + host: Some("127.0.0.1".to_string()), + port: Some(7777), + max_payload_bytes: Some(1200), + max_fragment_bytes: Some(1000), + max_pending_reliable_packets: Some(64), + }, + ); + + assert_eq!( + profile.transports[0].protocol, + CultNetTransportProtocol::Rudp + ); + let channels = profile.transports[0] + .channels + .iter() + .map(|channel| { + ( + channel.channel_id.as_str(), + channel.delivery, + channel.ordering, + channel.max_pending_reliable_packets, + ) + }) + .collect::>(); + assert_eq!( + channels, + vec![ + ( + "schema", + CultNetTransportDelivery::Reliable, + CultNetTransportOrdering::Ordered, + Some(64) + ), + ( + "latest", + CultNetTransportDelivery::Unreliable, + CultNetTransportOrdering::Sequenced, + Some(64) + ), + ( + "realtime", + CultNetTransportDelivery::Unreliable, + CultNetTransportOrdering::Unordered, + Some(64) + ), + ] + ); +} + +#[test] +fn rudp_session_handshake_acks_reliable_connect_and_accept_packets() -> Result<()> { + let mut client = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 0x0a0b0c0d, + initial_sequence: 1, + resend_delay_ms: 50, + ..CultNetRudpSessionOptions::default() + }); + let mut server = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 0x0a0b0c0d, + initial_sequence: 100, + resend_delay_ms: 50, + ..CultNetRudpSessionOptions::default() + }); + + let connect = client.create_connect(0, b"join".to_vec())?; + assert_eq!(connect.packet_type, CultNetRudpPacketType::Connect); + assert_eq!(connect.sequence, 1); + assert_eq!(client.pending_reliable_sequences(), vec![1]); + + let accept = server.accept_connect(&connect, 10, b"ok".to_vec())?; + assert_eq!(accept.packet_type, CultNetRudpPacketType::Accept); + assert_eq!(accept.ack, 1); + assert!(server.connected()); + assert_eq!(server.pending_reliable_sequences(), vec![100]); + + client.receive(&accept, 20)?; + assert!(client.connected()); + assert!(client.pending_reliable_sequences().is_empty()); + + let ack = client.create_ack(); + assert_eq!(ack.ack, 100); + server.receive(&ack, 30)?; + assert!(server.pending_reliable_sequences().is_empty()); + Ok(()) +} + +#[test] +fn rudp_session_computes_ack_masks_and_clears_pending_reliable_packets() -> Result<()> { + let mut sender = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 7, + initial_sequence: 10, + resend_delay_ms: 100, + ..CultNetRudpSessionOptions::default() + }); + let mut receiver = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 7, + initial_sequence: 200, + resend_delay_ms: 100, + ..CultNetRudpSessionOptions::default() + }); + sender.receive( + &CultNetRudpPacket { + packet_type: CultNetRudpPacketType::Accept, + connection_id: 7, + sequence: 1, + ack: 0, + ack_mask: 0, + channel_id: "control".to_string(), + reliable: false, + ordered: false, + sequenced: false, + fragment_id: 0, + fragment_index: 0, + fragment_count: 0, + payload: Vec::new(), + }, + 0, + )?; + receiver.receive( + &CultNetRudpPacket { + packet_type: CultNetRudpPacketType::Accept, + connection_id: 7, + sequence: 2, + ack: 0, + ack_mask: 0, + channel_id: "control".to_string(), + reliable: false, + ordered: false, + sequenced: false, + fragment_id: 0, + fragment_index: 0, + fragment_count: 0, + payload: Vec::new(), + }, + 0, + )?; + + let options = CultNetRudpSendOptions { + reliable: true, + ordered: true, + ..CultNetRudpSendOptions::default() + }; + let first = sender.send("schema", b"first".to_vec(), options.clone())?; + let second = sender.send("schema", b"second".to_vec(), options.clone())?; + let third = sender.send("schema", b"third".to_vec(), options)?; + assert_eq!(sender.pending_reliable_sequences(), vec![10, 11, 12]); + + receiver.receive(&first, 0)?; + receiver.receive(&third, 0)?; + let ack_with_gap = receiver.create_ack(); + assert_eq!(ack_with_gap.ack, 12); + assert_eq!(ack_with_gap.ack_mask, 0b10 | (1 << 9)); + sender.receive(&ack_with_gap, 0)?; + assert_eq!(sender.pending_reliable_sequences(), vec![11]); + + receiver.receive(&second, 0)?; + let full_ack = receiver.create_ack(); + assert_eq!(full_ack.ack, 12); + assert_eq!(full_ack.ack_mask, 0b11 | (1 << 9)); + sender.receive(&full_ack, 0)?; + assert!(sender.pending_reliable_sequences().is_empty()); + Ok(()) +} + +#[test] +fn rudp_session_schedules_reliable_resends_until_acked() -> Result<()> { + let mut session = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 99, + initial_sequence: 1, + resend_delay_ms: 100, + ..CultNetRudpSessionOptions::default() + }); + session.receive( + &CultNetRudpPacket { + packet_type: CultNetRudpPacketType::Accept, + connection_id: 99, + sequence: 50, + ack: 0, + ack_mask: 0, + channel_id: "control".to_string(), + reliable: false, + ordered: false, + sequenced: false, + fragment_id: 0, + fragment_index: 0, + fragment_count: 0, + payload: Vec::new(), + }, + 0, + )?; + let sent = session.send( + "schema", + b"payload".to_vec(), + CultNetRudpSendOptions { + reliable: true, + ordered: true, + now_ms: 10, + ..CultNetRudpSendOptions::default() + }, + )?; + + assert!(session.due_resends(90).is_empty()); + assert_eq!( + session + .due_resends(110) + .iter() + .map(|packet| packet.sequence) + .collect::>(), + vec![sent.sequence] + ); + assert!(session.due_resends(150).is_empty()); + + session.receive( + &CultNetRudpPacket { + packet_type: CultNetRudpPacketType::Ack, + connection_id: 99, + sequence: 51, + ack: sent.sequence, + ack_mask: 0, + channel_id: "control".to_string(), + reliable: false, + ordered: false, + sequenced: false, + fragment_id: 0, + fragment_index: 0, + fragment_count: 0, + payload: Vec::new(), + }, + 0, + )?; + assert!(session.due_resends(250).is_empty()); + Ok(()) +} + +#[test] +fn rudp_session_pings_and_detects_receive_timeout() -> Result<()> { + let mut client = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 101, + initial_sequence: 1, + ..CultNetRudpSessionOptions::default() + }); + let mut server = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 101, + initial_sequence: 100, + ..CultNetRudpSessionOptions::default() + }); + let connect = client.create_connect(0, b"join".to_vec())?; + let accept = server.accept_connect(&connect, 10, Vec::new())?; + client.receive(&accept, 20)?; + + let ping = client.create_ping(b"pulse".to_vec()); + let ping_result = server.receive(&ping, 30)?; + let pong = ping_result.reply.expect("ping should produce pong"); + assert_eq!(pong.packet_type, CultNetRudpPacketType::Pong); + assert_eq!(pong.payload, b"pulse"); + + let pong_result = client.receive(&pong, 40)?; + assert!(pong_result.pong); + assert_eq!(pong_result.pong_payload, b"pulse"); + assert!(!client.check_timeout(90, 50)); + assert!(client.check_timeout(91, 50)); + assert!(!client.connected()); + Ok(()) +} + +#[test] +fn rudp_session_bounds_pending_reliable_packets_before_enqueue() -> Result<()> { + let mut session = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 102, + initial_sequence: 1, + max_pending_reliable_packets: Some(2), + ..CultNetRudpSessionOptions::default() + }); + session.receive( + &CultNetRudpPacket { + packet_type: CultNetRudpPacketType::Accept, + connection_id: 102, + sequence: 50, + ack: 0, + ack_mask: 0, + channel_id: "control".to_string(), + reliable: false, + ordered: false, + sequenced: false, + fragment_id: 0, + fragment_index: 0, + fragment_count: 0, + payload: Vec::new(), + }, + 0, + )?; + session.send( + "schema", + b"first".to_vec(), + CultNetRudpSendOptions { + reliable: true, + ordered: true, + ..CultNetRudpSendOptions::default() + }, + )?; + session.send( + "schema", + b"second".to_vec(), + CultNetRudpSendOptions { + reliable: true, + ordered: true, + ..CultNetRudpSendOptions::default() + }, + )?; + let error = session + .send( + "schema", + b"third".to_vec(), + CultNetRudpSendOptions { + reliable: true, + ordered: true, + ..CultNetRudpSendOptions::default() + }, + ) + .unwrap_err(); + assert!(error.to_string().contains("reliable send queue is full")); + assert_eq!(session.pending_reliable_sequences(), vec![1, 2]); + + let mut fragmented = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 103, + initial_sequence: 1, + max_pending_reliable_packets: Some(3), + ..CultNetRudpSessionOptions::default() + }); + fragmented.receive( + &CultNetRudpPacket { + packet_type: CultNetRudpPacketType::Accept, + connection_id: 103, + sequence: 50, + ack: 0, + ack_mask: 0, + channel_id: "control".to_string(), + reliable: false, + ordered: false, + sequenced: false, + fragment_id: 0, + fragment_index: 0, + fragment_count: 0, + payload: Vec::new(), + }, + 0, + )?; + let error = fragmented + .send_many( + "schema", + b"fragment-me".to_vec(), + CultNetRudpSendOptions { + reliable: true, + ordered: true, + ..CultNetRudpSendOptions::default() + }, + Some(3), + ) + .unwrap_err(); + assert!(error.to_string().contains("reliable send queue is full")); + assert!(fragmented.pending_reliable_sequences().is_empty()); + Ok(()) +} + +#[test] +fn rudp_session_suppresses_duplicates_and_delivers_reliable_ordered_payloads_in_sequence() +-> Result<()> { + let mut sender = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 123, + initial_sequence: 1, + ..CultNetRudpSessionOptions::default() + }); + let mut receiver = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 123, + initial_sequence: 100, + ..CultNetRudpSessionOptions::default() + }); + sender.receive( + &CultNetRudpPacket { + packet_type: CultNetRudpPacketType::Accept, + connection_id: 123, + sequence: 90, + ack: 0, + ack_mask: 0, + channel_id: "control".to_string(), + reliable: false, + ordered: false, + sequenced: false, + fragment_id: 0, + fragment_index: 0, + fragment_count: 0, + payload: Vec::new(), + }, + 0, + )?; + receiver.receive( + &CultNetRudpPacket { + packet_type: CultNetRudpPacketType::Accept, + connection_id: 123, + sequence: 91, + ack: 0, + ack_mask: 0, + channel_id: "control".to_string(), + reliable: false, + ordered: false, + sequenced: false, + fragment_id: 0, + fragment_index: 0, + fragment_count: 0, + payload: Vec::new(), + }, + 0, + )?; + + let options = CultNetRudpSendOptions { + reliable: true, + ordered: true, + ..CultNetRudpSendOptions::default() + }; + let first = sender.send("schema", b"first".to_vec(), options.clone())?; + let second = sender.send("schema", b"second".to_vec(), options.clone())?; + let third = sender.send("schema", b"third".to_vec(), options)?; + + assert_eq!( + receiver + .receive(&first, 0)? + .delivered + .iter() + .map(|frame| String::from_utf8(frame.payload.clone()).unwrap()) + .collect::>(), + vec!["first"] + ); + assert!(receiver.receive(&third, 0)?.delivered.is_empty()); + assert!(receiver.receive(&first, 0)?.delivered.is_empty()); + assert_eq!( + receiver + .receive(&second, 0)? + .delivered + .iter() + .map(|frame| String::from_utf8(frame.payload.clone()).unwrap()) + .collect::>(), + vec!["second", "third"] + ); + Ok(()) +} + +#[test] +fn rudp_session_fragments_and_reassembles_reliable_ordered_payloads() -> Result<()> { + let mut sender = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 456, + initial_sequence: 1, + ..CultNetRudpSessionOptions::default() + }); + let mut receiver = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 456, + initial_sequence: 100, + ..CultNetRudpSessionOptions::default() + }); + sender.receive( + &CultNetRudpPacket { + packet_type: CultNetRudpPacketType::Accept, + connection_id: 456, + sequence: 90, + ack: 0, + ack_mask: 0, + channel_id: "control".to_string(), + reliable: false, + ordered: false, + sequenced: false, + fragment_id: 0, + fragment_index: 0, + fragment_count: 0, + payload: Vec::new(), + }, + 0, + )?; + receiver.receive( + &CultNetRudpPacket { + packet_type: CultNetRudpPacketType::Accept, + connection_id: 456, + sequence: 91, + ack: 0, + ack_mask: 0, + channel_id: "control".to_string(), + reliable: false, + ordered: false, + sequenced: false, + fragment_id: 0, + fragment_index: 0, + fragment_count: 0, + payload: Vec::new(), + }, + 0, + )?; + + let packets = sender.send_many( + "schema", + b"fragment-me-please".to_vec(), + CultNetRudpSendOptions { + reliable: true, + ordered: true, + now_ms: 10, + ..CultNetRudpSendOptions::default() + }, + Some(5), + )?; + assert_eq!(packets.len(), 4); + assert_eq!( + packets + .iter() + .map(|packet| packet.fragment_count) + .collect::>(), + vec![4, 4, 4, 4] + ); + assert_eq!( + packets + .iter() + .map(|packet| packet.fragment_index) + .collect::>(), + vec![0, 1, 2, 3] + ); + assert!( + packets + .iter() + .all(|packet| packet.fragment_id == packets[0].fragment_id) + ); + + assert!(receiver.receive(&packets[0], 0)?.delivered.is_empty()); + assert!(receiver.receive(&packets[1], 0)?.delivered.is_empty()); + assert!(receiver.receive(&packets[2], 0)?.delivered.is_empty()); + let delivered = receiver.receive(&packets[3], 0)?.delivered; + assert_eq!(delivered.len(), 1); + assert_eq!(delivered[0].payload, b"fragment-me-please"); + assert_eq!(delivered[0].sequence, packets[0].sequence); + Ok(()) +} + +#[test] +fn rudp_socket_transport_handshakes_and_carries_reliable_ordered_schema_frames() -> Result<()> { + let server_socket = bind_udp_socket()?; + let client_socket = bind_udp_socket()?; + let server_addr = server_socket.local_addr()?; + let connection_id = 0x1020_3040; + let mut server = + CultNetRudpSocketTransportConnection::new(CultNetRudpSocketTransportOptions { + runtime_id: "rust-rudp-server".to_string(), + socket: server_socket, + mode: CultNetRudpSocketMode::Server, + remote_addr: None, + connection_id, + initial_sequence: 100, + resend_delay_ms: 25, + transport_id: None, + max_payload_bytes: None, + max_fragment_bytes: None, + max_pending_reliable_packets: None, + })?; + let mut client = + CultNetRudpSocketTransportConnection::new(CultNetRudpSocketTransportOptions { + runtime_id: "rust-rudp-client".to_string(), + socket: client_socket, + mode: CultNetRudpSocketMode::Client, + remote_addr: Some(server_addr), + connection_id, + initial_sequence: 1, + resend_delay_ms: 25, + transport_id: None, + max_payload_bytes: None, + max_fragment_bytes: None, + max_pending_reliable_packets: None, + })?; + + client.connect(b"join".to_vec())?; + pump_rudp_handshake(&mut client, &mut server)?; + assert!(client.connected()); + assert!(server.connected()); + + client.send("schema", b"client-state".to_vec())?; + let server_frame = receive_rudp_frame(&mut server)?; + assert_eq!(server_frame.channel_id, "schema"); + assert_eq!(server_frame.payload, b"client-state"); + + server.send("schema", b"server-state".to_vec())?; + let client_frame = receive_rudp_frame(&mut client)?; + assert_eq!(client_frame.channel_id, "schema"); + assert_eq!(client_frame.payload, b"server-state"); + assert_eq!( + server.profile.transports[0].protocol, + CultNetTransportProtocol::Rudp + ); + assert_eq!(client.stats().frames_sent, 1); + assert_eq!(server.stats().frames_received, 1); + + Ok(()) +} + +#[test] +fn rudp_socket_transport_carries_fragmented_reliable_ordered_schema_frames() -> Result<()> { + let server_socket = bind_udp_socket()?; + let client_socket = bind_udp_socket()?; + let server_addr = server_socket.local_addr()?; + let connection_id = 0x1020_3041; + let mut server = + CultNetRudpSocketTransportConnection::new(CultNetRudpSocketTransportOptions { + runtime_id: "rust-rudp-fragment-server".to_string(), + socket: server_socket, + mode: CultNetRudpSocketMode::Server, + remote_addr: None, + connection_id, + initial_sequence: 100, + resend_delay_ms: 25, + transport_id: None, + max_payload_bytes: None, + max_fragment_bytes: Some(8), + max_pending_reliable_packets: None, + })?; + let mut client = + CultNetRudpSocketTransportConnection::new(CultNetRudpSocketTransportOptions { + runtime_id: "rust-rudp-fragment-client".to_string(), + socket: client_socket, + mode: CultNetRudpSocketMode::Client, + remote_addr: Some(server_addr), + connection_id, + initial_sequence: 1, + resend_delay_ms: 25, + transport_id: None, + max_payload_bytes: None, + max_fragment_bytes: Some(8), + max_pending_reliable_packets: None, + })?; + + client.connect(b"join".to_vec())?; + pump_rudp_handshake(&mut client, &mut server)?; + + let payload = b"this-schema-frame-is-larger-than-one-rudp-fragment".to_vec(); + client.send("schema", payload.clone())?; + let server_frame = receive_rudp_frame(&mut server)?; + assert_eq!(server_frame.channel_id, "schema"); + assert_eq!(server_frame.payload, payload); + assert_eq!(client.stats().frames_sent, 1); + assert_eq!(server.stats().frames_received, 1); + Ok(()) +} + #[test] fn legacy_gamecult_networking_contract_round_trips_login_union() -> Result<()> { let message = CultNetMessage::Login { @@ -146,6 +951,7 @@ fn rust_decodes_typescript_generated_cultnet_frames() -> Result<()> { supported_document_types: Some(vec!["ghostlight.agent-state".to_string()]), supported_mutation_contracts: None, supported_message_versions: None, + transport_profiles: None, supports_schema_catalog: None, } ); @@ -200,12 +1006,12 @@ fn document_registry_advertises_mutation_contracts_with_bindings() -> Result<()> #[test] fn document_registry_replicates_typed_cultcache_state() -> Result<()> { let temp = tempfile::tempdir()?; - let origin_store = temp.path().join("origin.cc"); - let target_store = temp.path().join("target.cc"); + let origin_store = temp.path().join("origin.msgpack"); + let target_store = temp.path().join("target.msgpack"); let payload = GhostlightAgentStateFixture { schema_version: "ghostlight.agent_state.v0".to_string(), - agent_id: "epiphany.face".to_string(), - display_name: "Face".to_string(), + agent_id: "epiphany.persona".to_string(), + display_name: "Persona".to_string(), }; let mut registry = CultNetDocumentRegistry::new(); @@ -217,7 +1023,7 @@ fn document_registry_replicates_typed_cultcache_state() -> Result<()> { origin.register_entry_type::()?; origin.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&origin_store)); origin.pull_all_backing_stores()?; - origin.put("epiphany.face", &payload)?; + origin.put("epiphany.persona", &payload)?; let snapshot = registry.create_snapshot_response(&origin, "snapshot-1", None, None)?; @@ -229,34 +1035,34 @@ fn document_registry_replicates_typed_cultcache_state() -> Result<()> { registry.apply_snapshot_response::(&mut target, &snapshot)?; assert_eq!(applied, vec![payload.clone()]); assert_eq!( - target.get_required::("epiphany.face")?, + target.get_required::("epiphany.persona")?, payload ); let direct_put = registry.create_document_put_message( "put-1", - "epiphany.face", + "epiphany.persona", &GhostlightAgentStateFixture { - display_name: "Face Prime".to_string(), + display_name: "Persona Prime".to_string(), ..payload }, CultNetDocumentPutOptions::default(), )?; let updated = registry .apply_document_put_message::(&mut target, &direct_put)?; - assert_eq!(updated.display_name, "Face Prime"); + assert_eq!(updated.display_name, "Persona Prime"); Ok(()) } #[test] fn raw_snapshot_replication_preserves_messagepack_payload_bytes() -> Result<()> { let temp = tempfile::tempdir()?; - let origin_store = temp.path().join("origin-raw.cc"); - let target_store = temp.path().join("target-raw.cc"); + let origin_store = temp.path().join("origin-raw.msgpack"); + let target_store = temp.path().join("target-raw.msgpack"); let payload = GhostlightAgentStateFixture { schema_version: "ghostlight.agent_state.v0".to_string(), - agent_id: "epiphany.face".to_string(), - display_name: "Face".to_string(), + agent_id: "epiphany.persona".to_string(), + display_name: "Persona".to_string(), }; let mut registry = CultNetDocumentRegistry::new(); @@ -268,12 +1074,12 @@ fn raw_snapshot_replication_preserves_messagepack_payload_bytes() -> Result<()> origin.register_entry_type::()?; origin.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&origin_store)); origin.pull_all_backing_stores()?; - origin.put("epiphany.face", &payload)?; + origin.put("epiphany.persona", &payload)?; let raw_snapshot = registry.create_raw_snapshot_response(&origin, "raw-snapshot-1", None, None)?; let source_envelope = - origin.get_required_envelope::("epiphany.face")?; + origin.get_required_envelope::("epiphany.persona")?; let mut target = CultCache::new(); target.register_entry_type::()?; @@ -282,12 +1088,12 @@ fn raw_snapshot_replication_preserves_messagepack_payload_bytes() -> Result<()> let applied = registry .apply_raw_snapshot_response::(&mut target, &raw_snapshot)?; let target_envelope = - target.get_required_envelope::("epiphany.face")?; + target.get_required_envelope::("epiphany.persona")?; assert_eq!(applied, vec![payload.clone()]); assert_eq!(target_envelope.payload, source_envelope.payload); assert_eq!( - target.get_required::("epiphany.face")?, + target.get_required::("epiphany.persona")?, payload ); Ok(()) @@ -328,6 +1134,21 @@ fn builtin_schema_registry_advertises_canonical_ghostlight_schema_without_inline ); assert_eq!(ghostlight.schema_json, None); assert!(!ghostlight.content_hash.is_empty()); + + let transport_profile = schemas + .iter() + .find(|schema| schema.schema_version.as_deref() == Some("cultnet.transport_profile.v0")) + .expect("transport profile schema is advertised"); + + assert_eq!(transport_profile.kind, CultNetSchemaKind::SharedContract); + assert_eq!( + transport_profile.schema_id, + "https://github.com/GameCult/cultnet-ts/contracts/cultnet.transport-profile.schema.json" + ); + assert_eq!( + transport_profile.wire_contracts, + vec![CultNetWireContract::CultNetSchemaV0] + ); Ok(()) }