From a80a269f4bd61e745bef4cfa052b58cce96ac89c Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Sun, 16 Aug 2026 21:22:24 +0200 Subject: [PATCH] Publish Ghostlight state through CultMesh --- Cargo.lock | 241 ++- Cargo.toml | 13 +- crates/ghostlight-dungeon/Cargo.toml | 3 + crates/ghostlight-dungeon/src/kernel.rs | 4 +- crates/ghostlight-dungeon/src/lib.rs | 1 + crates/ghostlight-dungeon/src/main.rs | 83 +- crates/ghostlight-dungeon/src/mesh.rs | 319 ++++ crates/ghostlight-dungeon/src/model.rs | 3 +- crates/ghostlight-dungeon/src/persistence.rs | 2 +- vendor/README.md | 10 + vendor/cultcache-rs/.gitignore | 2 + vendor/cultcache-rs/Cargo.toml | 24 + vendor/cultcache-rs/README.md | 332 ++++ .../cultcache-rs-derive/Cargo.toml | 13 + .../cultcache-rs-derive/src/lib.rs | 243 +++ .../examples/cultcache_interop.rs | 121 ++ vendor/cultcache-rs/src/lib.rs | 919 +++++++++++ vendor/cultmesh-rs/Cargo.lock | 1233 ++++++++++++++ vendor/cultmesh-rs/Cargo.toml | 20 + vendor/cultmesh-rs/src/lib.rs | 1277 +++++++++++++++ vendor/cultnet-rs/.gitignore | 2 + vendor/cultnet-rs/Cargo.toml | 32 + vendor/cultnet-rs/README.md | 96 ++ .../cultnet.document-delete.schema.json | 19 + ...net.document-mutation-contract.schema.json | 40 + .../cultnet.document-put-raw.schema.json | 19 + .../cultnet.document-put.schema.json | 19 + .../cultnet.document-record.schema.json | 26 + .../contracts/cultnet.error.schema.json | 15 + .../contracts/cultnet.hello.schema.json | 41 + .../cultnet.login-success.schema.json | 17 + .../contracts/cultnet.login.schema.json | 19 + .../cultnet.raw-document-record.schema.json | 32 + .../contracts/cultnet.register.schema.json | 21 + .../cultnet.sample-change-name.schema.json | 15 + .../contracts/cultnet.sample-chat.schema.json | 15 + ...cultnet.schema-catalog-request.schema.json | 31 + ...ultnet.schema-catalog-response.schema.json | 22 + .../cultnet.schema-descriptor.schema.json | 39 + .../cultnet.snapshot-request.schema.json | 23 + .../cultnet.snapshot-response-raw.schema.json | 22 + .../cultnet.snapshot-response.schema.json | 22 + .../cultnet.transport-profile.schema.json | 81 + .../contracts/cultnet.verify.schema.json | 17 + .../ghostlight.agent-state.schema.json | 845 ++++++++++ .../examples/cultnet_interop_peer.rs | 1026 ++++++++++++ vendor/cultnet-rs/src/contracts.rs | 1224 ++++++++++++++ vendor/cultnet-rs/src/framing.rs | 49 + vendor/cultnet-rs/src/lib.rs | 15 + vendor/cultnet-rs/src/replication.rs | 440 +++++ vendor/cultnet-rs/src/rudp.rs | 1444 +++++++++++++++++ vendor/cultnet-rs/src/schema_discovery.rs | 396 +++++ vendor/cultnet-rs/src/security.rs | 270 +++ vendor/cultnet-rs/src/transport.rs | 194 +++ vendor/cultnet-rs/tests/cultnet.rs | 1352 +++++++++++++++ .../tests/fixtures/cultnet-ts-hello.frame | Bin 0 -> 160 bytes .../fixtures/cultnet-ts-legacy-login.frame | Bin 0 -> 30 bytes 57 files changed, 12783 insertions(+), 20 deletions(-) create mode 100644 crates/ghostlight-dungeon/src/mesh.rs create mode 100644 vendor/README.md create mode 100644 vendor/cultcache-rs/.gitignore create mode 100644 vendor/cultcache-rs/Cargo.toml create mode 100644 vendor/cultcache-rs/README.md create mode 100644 vendor/cultcache-rs/cultcache-rs-derive/Cargo.toml create mode 100644 vendor/cultcache-rs/cultcache-rs-derive/src/lib.rs create mode 100644 vendor/cultcache-rs/examples/cultcache_interop.rs create mode 100644 vendor/cultcache-rs/src/lib.rs create mode 100644 vendor/cultmesh-rs/Cargo.lock create mode 100644 vendor/cultmesh-rs/Cargo.toml create mode 100644 vendor/cultmesh-rs/src/lib.rs create mode 100644 vendor/cultnet-rs/.gitignore create mode 100644 vendor/cultnet-rs/Cargo.toml create mode 100644 vendor/cultnet-rs/README.md create mode 100644 vendor/cultnet-rs/contracts/cultnet.document-delete.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.document-mutation-contract.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.document-put-raw.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.document-put.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.document-record.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.error.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.hello.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.login-success.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.login.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.raw-document-record.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.register.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.sample-change-name.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.sample-chat.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.schema-catalog-request.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.schema-catalog-response.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.schema-descriptor.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.snapshot-request.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.snapshot-response-raw.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.snapshot-response.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.transport-profile.schema.json create mode 100644 vendor/cultnet-rs/contracts/cultnet.verify.schema.json create mode 100644 vendor/cultnet-rs/contracts/ghostlight.agent-state.schema.json create mode 100644 vendor/cultnet-rs/examples/cultnet_interop_peer.rs create mode 100644 vendor/cultnet-rs/src/contracts.rs create mode 100644 vendor/cultnet-rs/src/framing.rs create mode 100644 vendor/cultnet-rs/src/lib.rs create mode 100644 vendor/cultnet-rs/src/replication.rs create mode 100644 vendor/cultnet-rs/src/rudp.rs create mode 100644 vendor/cultnet-rs/src/schema_discovery.rs create mode 100644 vendor/cultnet-rs/src/security.rs create mode 100644 vendor/cultnet-rs/src/transport.rs create mode 100644 vendor/cultnet-rs/tests/cultnet.rs create mode 100644 vendor/cultnet-rs/tests/fixtures/cultnet-ts-hello.frame create mode 100644 vendor/cultnet-rs/tests/fixtures/cultnet-ts-legacy-login.frame diff --git a/Cargo.lock b/Cargo.lock index c12d566..0ce89d8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,6 +2,41 @@ # It is not intended for manual editing. version = 4 +[[package]] +name = "aead" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0" +dependencies = [ + "crypto-common", + "generic-array", +] + +[[package]] +name = "aes" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" +dependencies = [ + "cfg-if", + "cipher", + "cpufeatures 0.2.17", +] + +[[package]] +name = "aes-gcm" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1" +dependencies = [ + "aead", + "aes", + "cipher", + "ctr", + "ghash", + "subtle", +] + [[package]] name = "aho-corasick" version = "1.1.5" @@ -193,6 +228,16 @@ dependencies = [ "windows-link 0.2.1", ] +[[package]] +name = "cipher" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" +dependencies = [ + "crypto-common", + "inout", +] + [[package]] name = "core-foundation-sys" version = "0.8.7" @@ -224,9 +269,36 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" dependencies = [ "generic-array", + "rand_core 0.6.4", "typenum", ] +[[package]] +name = "ctr" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835" +dependencies = [ + "cipher", +] + +[[package]] +name = "cultcache-rs" +version = "0.1.0" +dependencies = [ + "anyhow", + "chrono", + "cultcache-rs-derive 0.1.0", + "fs2", + "pretty_assertions", + "rmp-serde", + "serde", + "serde_bytes", + "serde_json", + "tempfile", + "uuid", +] + [[package]] name = "cultcache-rs" version = "0.1.0" @@ -234,7 +306,7 @@ source = "git+https://github.com/GameCult/cultcache-rs.git?rev=0ba87453115e3d44e dependencies = [ "anyhow", "chrono", - "cultcache-rs-derive", + "cultcache-rs-derive 0.1.0 (git+https://github.com/GameCult/cultcache-rs.git?rev=0ba87453115e3d44e8fcb7419866cd7dd70fb096)", "fs2", "redb", "rmp-serde", @@ -245,6 +317,15 @@ dependencies = [ "windows-sys 0.59.0", ] +[[package]] +name = "cultcache-rs-derive" +version = "0.1.0" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "cultcache-rs-derive" version = "0.1.0" @@ -255,6 +336,48 @@ dependencies = [ "syn 2.0.119", ] +[[package]] +name = "cultmesh-rs" +version = "0.1.0" +dependencies = [ + "anyhow", + "cultcache-rs 0.1.0", + "cultnet-rs", + "pretty_assertions", + "rmp-serde", + "serde", + "tempfile", +] + +[[package]] +name = "cultnet-rs" +version = "0.1.0" +dependencies = [ + "aes-gcm", + "anyhow", + "base64", + "chrono", + "cultcache-rs 0.1.0", + "hmac", + "pretty_assertions", + "rand 0.9.5", + "rmp-serde", + "rmpv", + "serde", + "serde_bytes", + "serde_json", + "sha2", + "socket2 0.5.10", + "tempfile", + "uuid", +] + +[[package]] +name = "diff" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8" + [[package]] name = "digest" version = "0.10.7" @@ -263,6 +386,7 @@ checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" dependencies = [ "block-buffer", "crypto-common", + "subtle", ] [[package]] @@ -432,6 +556,16 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "ghash" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1" +dependencies = [ + "opaque-debug", + "polyval", +] + [[package]] name = "ghostlight-dungeon" version = "0.1.0" @@ -440,7 +574,10 @@ dependencies = [ "async-trait", "axum", "chrono", - "cultcache-rs", + "cultcache-rs 0.1.0", + "cultcache-rs 0.1.0 (git+https://github.com/GameCult/cultcache-rs.git?rev=0ba87453115e3d44e8fcb7419866cd7dd70fb096)", + "cultmesh-rs", + "cultnet-rs", "rand 0.9.5", "reqwest", "rmp-serde", @@ -459,6 +596,15 @@ dependencies = [ "zeroize", ] +[[package]] +name = "hmac" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +dependencies = [ + "digest", +] + [[package]] name = "http" version = "1.5.0" @@ -564,7 +710,7 @@ dependencies = [ "libc", "percent-encoding", "pin-project-lite", - "socket2", + "socket2 0.6.5", "tokio", "tower-service", "tracing", @@ -698,6 +844,15 @@ dependencies = [ "icu_properties", ] +[[package]] +name = "inout" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" +dependencies = [ + "generic-array", +] + [[package]] name = "ipnet" version = "2.12.1" @@ -838,6 +993,12 @@ version = "1.21.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" +[[package]] +name = "opaque-debug" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" + [[package]] name = "parking_lot" version = "0.12.5" @@ -873,6 +1034,18 @@ version = "0.2.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" +[[package]] +name = "polyval" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25" +dependencies = [ + "cfg-if", + "cpufeatures 0.2.17", + "opaque-debug", + "universal-hash", +] + [[package]] name = "potential_utf" version = "0.1.6" @@ -891,6 +1064,16 @@ dependencies = [ "zerocopy", ] +[[package]] +name = "pretty_assertions" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d" +dependencies = [ + "diff", + "yansi", +] + [[package]] name = "proc-macro2" version = "1.0.107" @@ -913,7 +1096,7 @@ dependencies = [ "quinn-udp", "rustc-hash", "rustls", - "socket2", + "socket2 0.6.5", "thiserror", "tokio", "tracing", @@ -951,7 +1134,7 @@ dependencies = [ "cfg_aliases", "libc", "once_cell", - "socket2", + "socket2 0.6.5", "tracing", "windows-sys 0.61.2", ] @@ -1008,6 +1191,15 @@ dependencies = [ "rand_core 0.9.5", ] +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.17", +] + [[package]] name = "rand_core" version = "0.9.5" @@ -1161,6 +1353,17 @@ dependencies = [ "serde", ] +[[package]] +name = "rmpv" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a4e1d4b9b938a26d2996af33229f0ca0956c652c1375067f0b45291c1df8417" +dependencies = [ + "rmp", + "serde", + "serde_bytes", +] + [[package]] name = "rustc-hash" version = "2.1.3" @@ -1395,6 +1598,16 @@ version = "1.15.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90" +[[package]] +name = "socket2" +version = "0.5.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678" +dependencies = [ + "libc", + "windows-sys 0.52.0", +] + [[package]] name = "socket2" version = "0.6.5" @@ -1538,7 +1751,7 @@ dependencies = [ "parking_lot", "pin-project-lite", "signal-hook-registry", - "socket2", + "socket2 0.6.5", "tokio-macros", "windows-sys 0.61.2", ] @@ -1719,6 +1932,16 @@ version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" +[[package]] +name = "universal-hash" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea" +dependencies = [ + "crypto-common", + "subtle", +] + [[package]] name = "untrusted" version = "0.9.0" @@ -2161,6 +2384,12 @@ version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc" +[[package]] +name = "yansi" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049" + [[package]] name = "yoke" version = "0.8.3" diff --git a/Cargo.toml b/Cargo.toml index 30969dc..f61abd0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,11 @@ [workspace] -members = ["crates/ghostlight-dungeon"] +members = [ + "crates/ghostlight-dungeon", + "vendor/cultcache-rs", + "vendor/cultcache-rs/cultcache-rs-derive", + "vendor/cultnet-rs", + "vendor/cultmesh-rs", +] resolver = "2" [workspace.package] @@ -12,7 +18,10 @@ anyhow = "1" async-trait = "0.1" axum = { version = "0.8", features = ["macros"] } chrono = { version = "0.4", features = ["serde"] } -cultcache-rs = { git = "https://github.com/GameCult/cultcache-rs.git", rev = "0ba87453115e3d44e8fcb7419866cd7dd70fb096" } +cultcache-legacy = { package = "cultcache-rs", git = "https://github.com/GameCult/cultcache-rs.git", rev = "0ba87453115e3d44e8fcb7419866cd7dd70fb096" } +cultcache-rs = { path = "vendor/cultcache-rs" } +cultnet-rs = { path = "vendor/cultnet-rs" } +cultmesh-rs = { path = "vendor/cultmesh-rs" } rand = "0.9" reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls", "stream"] } rmp-serde = "1.3" diff --git a/crates/ghostlight-dungeon/Cargo.toml b/crates/ghostlight-dungeon/Cargo.toml index 556e73a..07dc5b9 100644 --- a/crates/ghostlight-dungeon/Cargo.toml +++ b/crates/ghostlight-dungeon/Cargo.toml @@ -9,7 +9,10 @@ anyhow.workspace = true async-trait.workspace = true axum.workspace = true chrono.workspace = true +cultcache-legacy.workspace = true cultcache-rs.workspace = true +cultnet-rs.workspace = true +cultmesh-rs.workspace = true rand.workspace = true reqwest.workspace = true rmp-serde.workspace = true diff --git a/crates/ghostlight-dungeon/src/kernel.rs b/crates/ghostlight-dungeon/src/kernel.rs index 97cd59b..0ae8b18 100644 --- a/crates/ghostlight-dungeon/src/kernel.rs +++ b/crates/ghostlight-dungeon/src/kernel.rs @@ -796,7 +796,7 @@ fn assess(c: &Campaign, intent: ActionIntent) -> ActionAssessment { fn commit( store: &CampaignStore, - row: cultcache_rs::CultCacheEnvelope, + row: cultcache_legacy::CultCacheEnvelope, mut campaign: Campaign, kind: &str, roll: Option, @@ -828,7 +828,7 @@ fn commit( fn commit_with_records( store: &CampaignStore, - row: cultcache_rs::CultCacheEnvelope, + row: cultcache_legacy::CultCacheEnvelope, mut campaign: Campaign, kind: &str, evidence: Vec, diff --git a/crates/ghostlight-dungeon/src/lib.rs b/crates/ghostlight-dungeon/src/lib.rs index 2295be4..9f1f689 100644 --- a/crates/ghostlight-dungeon/src/lib.rs +++ b/crates/ghostlight-dungeon/src/lib.rs @@ -5,6 +5,7 @@ pub mod domain; pub mod gestalt; pub mod initiative; pub mod kernel; +pub mod mesh; pub mod model; pub mod narrator; pub mod persistence; diff --git a/crates/ghostlight-dungeon/src/main.rs b/crates/ghostlight-dungeon/src/main.rs index 92a3360..6bb6ef7 100644 --- a/crates/ghostlight-dungeon/src/main.rs +++ b/crates/ghostlight-dungeon/src/main.rs @@ -16,6 +16,7 @@ use ghostlight_dungeon::{ }, gestalt::GestaltPresencePlanner, kernel::CommandResult, + mesh::MeshPublisher, model::{DeepSeekPort, ModelPort, ModelStageRequest, run_validated_stage}, narrator::Narrator, persistence::CampaignStore, @@ -51,6 +52,7 @@ struct AppState { compile_previews: Arc>>>, expansion_previews: Arc>>>, live_turns: Arc, + mesh: MeshPublisher, } struct LiveTurnGuard(Arc); @@ -85,7 +87,7 @@ struct AuthState { struct AuthOwner { store: CampaignStore, - row: cultcache_rs::CultCacheEnvelope, + row: cultcache_legacy::CultCacheEnvelope, state: AuthState, } @@ -181,6 +183,11 @@ async fn main() -> anyhow::Result<()> { } else { ("missing-secret".into(), None, None, None) }; + let mesh_target = std::env::var("GHOSTLIGHT_ODIN_RUDP") + .ok() + .map(|value| value.parse()) + .transpose()?; + let mesh = MeshPublisher::open(runtime_root.join("service/mesh.cc"), mesh_target)?; let state = AppState { registry, runtime_root, @@ -196,7 +203,9 @@ async fn main() -> anyhow::Result<()> { compile_previews: Arc::new(Mutex::new(BTreeMap::new())), expansion_previews: Arc::new(Mutex::new(BTreeMap::new())), live_turns: Arc::new(AtomicUsize::new(0)), + mesh, }; + refresh_mesh(&state).await?; tokio::spawn(scheduler_loop(state.clone())); let release_web_root = std::env::current_exe()? .parent() @@ -239,10 +248,11 @@ async fn main() -> anyhow::Result<()> { Ok(()) } -async fn health(State(state): State) -> Json { - Json( - serde_json::json!({"schema":"ghostlight.service_health.v1","status":"ok","campaigns":state.registry.list().await.len(),"deepseek":state.deepseek_status}), - ) +async fn health(State(state): State) -> Response { + match state.mesh.health() { + Ok(value) => Json(value).into_response(), + Err(error) => (StatusCode::SERVICE_UNAVAILABLE, error.to_string()).into_response(), + } } async fn invite(Path(token): Path, State(state): State) -> Response { @@ -483,7 +493,12 @@ async fn approve_preview( { Ok(runtime) => match select_campaign(&state, &session, campaign_id).await { Ok(()) => match load_campaign(&runtime.store) { - Ok(campaign) => Json(CommandResult::Created { campaign }).into_response(), + Ok(campaign) => { + if let Err(error) = refresh_mesh(&state).await { + tracing::warn!(%error, "campaign approval CultMesh publication failed"); + } + Json(CommandResult::Created { campaign }).into_response() + } Err(error) => { (StatusCode::INTERNAL_SERVER_ERROR, error.to_string()).into_response() } @@ -900,6 +915,9 @@ async fn command( .await .ok() .flatten(); + if let Err(error) = refresh_mesh(&state).await { + tracing::warn!(%error, "post-command CultMesh publication failed"); + } return Json(serde_json::json!({"primary":result,"presence":presence_result,"reaction_wave":reaction,"npc_initiative":initiative,"narration":narration})).into_response(); } Err(error) => { @@ -930,6 +948,9 @@ async fn command( .await .ok() .flatten(); + if let Err(error) = refresh_mesh(&state).await { + tracing::warn!(%error, "post-command CultMesh publication failed"); + } return Json( serde_json::json!({"primary":result,"presence":presence_result,"narration":narration}), ) @@ -946,6 +967,9 @@ async fn command( .await .ok() .flatten(); + if let Err(error) = refresh_mesh(&state).await { + tracing::warn!(%error, "post-command CultMesh publication failed"); + } Json(serde_json::json!({"result":result,"narration":narration})).into_response() } else { Json(result).into_response() @@ -1001,9 +1025,41 @@ async fn scheduler_loop(state: AppState) { } } } + if let Err(error) = refresh_mesh(&state).await { + tracing::warn!(%error, "CultMesh projection refresh failed"); + } } } +async fn refresh_mesh(state: &AppState) -> anyhow::Result { + let mut snapshots = Vec::new(); + for id in state.registry.list().await { + let runtime = state.registry.runtime(id).await?; + let campaign = load_campaign(&runtime.store)?; + let mut narrations = runtime + .store + .keys("narration_projection.v1")? + .into_iter() + .filter_map(|key| { + runtime + .store + .load::("narration_projection.v1", &key) + .ok() + .flatten() + .map(|(_, value)| value) + }) + .filter(|value| value.campaign_id == campaign.id) + .collect::>(); + narrations.sort_by_key(|value| value.source_revision); + snapshots.push((campaign, narrations)); + } + let publisher = state.mesh.clone(); + let deepseek = state.deepseek_status.clone(); + let pressure = state.live_turns.load(Ordering::SeqCst); + tokio::task::spawn_blocking(move || publisher.publish_snapshot(&snapshots, &deepseek, pressure)) + .await? +} + #[derive(Deserialize)] struct CampaignBranchRequest { name: String, @@ -1099,7 +1155,12 @@ async fn fork_campaign( } }; match select_campaign(&state, &session, campaign.id).await { - Ok(()) => Json(campaign).into_response(), + Ok(()) => { + if let Err(error) = refresh_mesh(&state).await { + tracing::warn!(%error, "campaign fork CultMesh publication failed"); + } + Json(campaign).into_response() + } Err(error) => { (StatusCode::INTERNAL_SERVER_ERROR, error.to_string()).into_response() } @@ -1139,7 +1200,12 @@ async fn reset_campaign( } }; match select_campaign(&state, &session, campaign.id).await { - Ok(()) => Json(campaign).into_response(), + Ok(()) => { + if let Err(error) = refresh_mesh(&state).await { + tracing::warn!(%error, "campaign reset CultMesh publication failed"); + } + Json(campaign).into_response() + } Err(error) => { (StatusCode::INTERNAL_SERVER_ERROR, error.to_string()).into_response() } @@ -1474,6 +1540,7 @@ mod tests { compile_previews: Arc::new(Mutex::new(BTreeMap::new())), expansion_previews: Arc::new(Mutex::new(BTreeMap::new())), live_turns: Arc::new(AtomicUsize::new(0)), + mesh: MeshPublisher::open(dir.path().join("mesh.cc"), None).unwrap(), }; let left_runtime = session_runtime(&state, "left").await.unwrap().unwrap(); let right_runtime = session_runtime(&state, "right").await.unwrap().unwrap(); diff --git a/crates/ghostlight-dungeon/src/mesh.rs b/crates/ghostlight-dungeon/src/mesh.rs new file mode 100644 index 0000000..9a91f57 --- /dev/null +++ b/crates/ghostlight-dungeon/src/mesh.rs @@ -0,0 +1,319 @@ +use crate::{ + domain::{ + ActionAssessment, ActorState, ActorStateDelta, Campaign, CanonCandidate, Event, + GestaltMemberDelta, GestaltPersonaState, InstitutionState, Location, NarrationProjection, + NewsIssue, RollReceipt, VaultEvidenceReceipt, WorldActionProposal, WorldClock, + WorldCommitReceipt, WorldCompilePreview, WorldFact, + }, + model::ModelStageReceipt, + surface::player_surface, +}; +use anyhow::{Context, Result}; +use chrono::Utc; +use cultcache_rs::DatabaseEntry; +use cultmesh_rs::{ + CultMesh, CultMeshNode, CultMeshNodeOptions, CultMeshRudpDocumentPublishOptions, +}; +use serde_json::{Value, json}; +use std::{ + net::SocketAddr, + path::Path, + sync::{Arc, Mutex}, +}; + +pub const PROVIDER_ID: &str = "gamecult.ghostlight.dungeon"; +pub const HEALTH_KEY: &str = "ghostlight:dungeon:health"; +pub const ADVERTISEMENT_KEY: &str = "eve:provider:gamecult.ghostlight.dungeon"; + +#[derive(Clone, Debug, PartialEq, DatabaseEntry)] +#[cultcache(type = "gamecult.eve.surface", schema = "gamecult.eve.surface.v1")] +pub struct EveSurfaceRecord { + #[cultcache(key = 0)] + pub value: Value, +} + +#[derive(Clone, Debug, PartialEq, DatabaseEntry)] +#[cultcache( + type = "gamecult.eve.surface_state", + schema = "gamecult.eve.surface_state.v1" +)] +pub struct EveSurfaceStateRecord { + #[cultcache(key = 0)] + pub provider_id: String, + #[cultcache(key = 1)] + pub title: String, + #[cultcache(key = 2)] + pub version: i64, + #[cultcache(key = 3)] + pub updated_at: String, + #[cultcache(key = 4)] + pub surface: Value, +} + +#[derive(Clone, Debug, PartialEq, DatabaseEntry)] +#[cultcache( + type = "gamecult.eve.provider_advertisement", + schema = "gamecult.eve.provider_advertisement.v1" +)] +pub struct EveProviderAdvertisementRecord { + #[cultcache(key = 0)] + pub value: Value, +} + +#[derive(Clone, Debug, PartialEq, DatabaseEntry)] +#[cultcache( + type = "ghostlight.service_health", + schema = "ghostlight.service_health.v1" +)] +pub struct ServiceHealthRecord { + #[cultcache(key = 0)] + pub value: Value, +} + +#[derive(Clone, Debug, PartialEq, DatabaseEntry)] +#[cultcache( + type = "ghostlight.schema_catalog", + schema = "ghostlight.schema_catalog.v1" +)] +pub struct SchemaCatalogRecord { + #[cultcache(key = 0)] + pub value: Value, +} + +cultmesh_rs::cultmesh_documents!(GhostlightDocuments { + EveSurfaceRecord => "gamecult.eve.surface.v1", + EveSurfaceStateRecord => "gamecult.eve.surface_state.v1", + EveProviderAdvertisementRecord => "gamecult.eve.provider_advertisement.v1", + ServiceHealthRecord => "ghostlight.service_health.v1", + SchemaCatalogRecord => "ghostlight.schema_catalog.v1", +}); + +#[derive(Clone)] +pub struct MeshPublisher { + node: Arc>, + rudp_target: Option, +} + +impl MeshPublisher { + pub fn open(store_path: impl AsRef, rudp_target: Option) -> Result { + if let Some(parent) = store_path.as_ref().parent() { + std::fs::create_dir_all(parent)?; + } + let node = CultMesh::create_node( + store_path, + GhostlightDocuments, + CultMeshNodeOptions { + runtime_id: "ghostlight-dungeon-starfire".into(), + pull_on_start: true, + }, + )?; + Ok(Self { + node: Arc::new(Mutex::new(node)), + rudp_target, + }) + } + + pub fn publish_snapshot( + &self, + campaigns: &[(Campaign, Vec)], + deepseek_status: &str, + live_turn_pressure: usize, + ) -> Result { + let updated_at = Utc::now().to_rfc3339(); + let health = json!({ + "schema":"ghostlight.service_health.v1", + "status":"ok", + "campaigns":campaigns.len(), + "deepseek":deepseek_status, + "scheduler":{"live_turn_pressure":live_turn_pressure}, + "updatedAtUtc":updated_at, + "runtime":"ghostlight-dungeon-starfire", + "commit":option_env!("GHOSTLIGHT_BUILD_COMMIT").unwrap_or("development") + }); + let schema_ids = vec![ + "gamecult.eve.surface.v1", + "gamecult.eve.surface_state.v1", + "gamecult.eve.provider_advertisement.v1", + "ghostlight.service_health.v1", + "ghostlight.schema_catalog.v1", + "ghostlight.campaign.v1", + "ghostlight.player_action_assessment.v1", + "ghostlight.roll_receipt.v1", + "ghostlight.world_commit_receipt.v1", + "ghostlight.persona_stage_receipt.v1", + "ghostlight.actor_state_delta.v1", + "ghostlight.world_action_proposal.v1", + "ghostlight.strategic_tick.v1", + "ghostlight.news_issue.v1", + "ghostlight.canon_candidate.v1", + ]; + let catalog = json!({ + "schema":"ghostlight.schema_catalog.v1", + "providerId":PROVIDER_ID, + "schemas":schema_catalog(), + "updatedAtUtc":updated_at + }); + let surfaces = campaigns + .iter() + .map(|(campaign, _)| { + json!({ + "schema":"gamecult.eve.surface.v1", + "surfaceId":format!("ghostlight.campaign.{}",campaign.id), + "key":format!("eve:surface:ghostlight.campaign.{}",campaign.id), + "transport":"cultmesh-record", + "status":"available", + "audience":"authenticated-player", + "mode":"interactive", + "surfaceKind":"interactive-world", + "interactionModel":"provider-command-receipts" + }) + }) + .collect::>(); + let advertisement = json!({ + "schema":"gamecult.eve.provider_advertisement.v1", + "providerId":PROVIDER_ID, + "serviceId":"ghostlight-dungeon-starfire", + "verseId":"gamecult.private", + "rootVerse":"gamecult", + "canonicalService":"ghostlight-dungeon", + "locatedService":"starfire", + "cultMeshAddress":"cultmesh://gamecult.private/ghostlight/providers/dungeon", + "title":"GhostlightDungeon", + "kind":"narrative.simulation", + "updatedAtUtc":updated_at, + "freshness":{"state":"live","lastSeenAtUtc":updated_at,"maxAgeMs":360000}, + "schemas":schema_ids, + "surfaces":surfaces, + "commands":[{"command":"ghostlight.world.commands","schema":"gamecult.eve.command.v1","transport":"cultmesh","summary":"Revision-bound world command intents; WorldKernel owns receipts."}] + }); + + let mut node = self + .node + .lock() + .map_err(|_| anyhow::anyhow!("mesh lock poisoned"))?; + self.put_and_publish( + &mut node, + HEALTH_KEY, + &ServiceHealthRecord { + value: health.clone(), + }, + )?; + self.put_and_publish( + &mut node, + "ghostlight:schema-catalog", + &SchemaCatalogRecord { value: catalog }, + )?; + self.put_and_publish( + &mut node, + ADVERTISEMENT_KEY, + &EveProviderAdvertisementRecord { + value: advertisement, + }, + )?; + for (campaign, narrations) in campaigns { + let surface = player_surface(campaign, narrations); + let key = format!("eve:surface:ghostlight.campaign.{}", campaign.id); + self.put_and_publish( + &mut node, + &key, + &EveSurfaceRecord { + value: surface.clone(), + }, + )?; + self.put_and_publish( + &mut node, + format!("eve:surface-state:ghostlight.campaign.{}", campaign.id), + &EveSurfaceStateRecord { + provider_id: PROVIDER_ID.into(), + title: campaign.name.clone(), + version: campaign.revision as i64, + updated_at: updated_at.clone(), + surface, + }, + )?; + } + node.flush()?; + Ok(health) + } + + pub fn health(&self) -> Result { + self.node + .lock() + .map_err(|_| anyhow::anyhow!("mesh lock poisoned"))? + .get_required::(HEALTH_KEY) + .map(|record| record.value) + } + + fn put_and_publish( + &self, + node: &mut CultMeshNode, + key: impl Into, + value: &T, + ) -> Result<()> + where + T: DatabaseEntry + serde::Serialize, + { + let key = key.into(); + node.put(&key, value)?; + if let Some(target) = self.rudp_target { + let mut options = + CultMeshRudpDocumentPublishOptions::odin(target, "ghostlight-dungeon-starfire"); + options.source_agent_id = Some(PROVIDER_ID.into()); + options.source_role = Some("narrative-simulation".into()); + options.tags = vec!["ghostlight".into(), "eve".into(), "private".into()]; + node.publish_document_to_rudp_catalog(&key, value, options) + .with_context(|| format!("publish {key} to Odin RUDP catalog"))?; + } + Ok(()) + } +} + +fn schema_catalog() -> Value { + json!({ + "ghostlight.vault_evidence_receipt.v1": schemars::schema_for!(VaultEvidenceReceipt), + "ghostlight.world_compile_preview.v1": schemars::schema_for!(WorldCompilePreview), + "ghostlight.campaign.v1": schemars::schema_for!(Campaign), + "ghostlight.world_fact.v1": schemars::schema_for!(WorldFact), + "ghostlight.location.v1": schemars::schema_for!(Location), + "ghostlight.actor_state.v1": schemars::schema_for!(ActorState), + "ghostlight.institution_state.v1": schemars::schema_for!(InstitutionState), + "ghostlight.world_clock.v1": schemars::schema_for!(WorldClock), + "ghostlight.event.v1": schemars::schema_for!(Event), + "ghostlight.player_action_assessment.v1": schemars::schema_for!(ActionAssessment), + "ghostlight.roll_receipt.v1": schemars::schema_for!(RollReceipt), + "ghostlight.world_commit_receipt.v1": schemars::schema_for!(WorldCommitReceipt), + "ghostlight.persona_stage_receipt.v1": schemars::schema_for!(ModelStageReceipt), + "ghostlight.actor_state_delta.v1": schemars::schema_for!(ActorStateDelta), + "ghostlight.world_action_proposal.v1": schemars::schema_for!(WorldActionProposal), + "ghostlight.news_issue.v1": schemars::schema_for!(NewsIssue), + "ghostlight.canon_candidate.v1": schemars::schema_for!(CanonCandidate), + "ghostlight.gestalt_persona_state.v1": schemars::schema_for!(GestaltPersonaState), + "ghostlight.gestalt_member_delta.v1": schemars::schema_for!(GestaltMemberDelta) + }) +} + +#[cfg(test)] +mod tests { + use super::*; + use tempfile::tempdir; + + #[test] + fn health_is_read_from_the_same_typed_mesh_record_that_is_published() { + let temp = tempdir().unwrap(); + let publisher = MeshPublisher::open(temp.path().join("mesh.cc"), None).unwrap(); + let written = publisher.publish_snapshot(&[], "fixture-ready", 2).unwrap(); + assert_eq!(publisher.health().unwrap(), written); + assert_eq!(written["scheduler"]["live_turn_pressure"], 2); + let catalog = publisher + .node + .lock() + .unwrap() + .get_required::("ghostlight:schema-catalog") + .unwrap(); + assert!(catalog.value["schemas"]["ghostlight.campaign.v1"]["$schema"].is_string()); + drop(catalog); + drop(publisher); + let reopened = MeshPublisher::open(temp.path().join("mesh.cc"), None).unwrap(); + assert_eq!(reopened.health().unwrap(), written); + } +} diff --git a/crates/ghostlight-dungeon/src/model.rs b/crates/ghostlight-dungeon/src/model.rs index e221147..ab5492d 100644 --- a/crates/ghostlight-dungeon/src/model.rs +++ b/crates/ghostlight-dungeon/src/model.rs @@ -1,5 +1,6 @@ use anyhow::{Result, anyhow}; use async_trait::async_trait; +use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; use std::time::Instant; @@ -15,7 +16,7 @@ pub struct ModelStageRequest { pub source_receipt_ids: Vec, } -#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] +#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq)] pub struct ModelStageReceipt { pub schema: String, pub provider: String, diff --git a/crates/ghostlight-dungeon/src/persistence.rs b/crates/ghostlight-dungeon/src/persistence.rs index 25e4eac..b9436c6 100644 --- a/crates/ghostlight-dungeon/src/persistence.rs +++ b/crates/ghostlight-dungeon/src/persistence.rs @@ -1,7 +1,7 @@ use crate::domain::{Campaign, VaultEvidenceReceipt}; use anyhow::{Context, Result, anyhow}; use chrono::Utc; -use cultcache_rs::{CacheBackingStore, CultCacheEnvelope, OwnedRedbMessagePackBackingStore}; +use cultcache_legacy::{CacheBackingStore, CultCacheEnvelope, OwnedRedbMessagePackBackingStore}; use serde::{Serialize, de::DeserializeOwned}; use std::path::Path; diff --git a/vendor/README.md b/vendor/README.md new file mode 100644 index 0000000..ef1968a --- /dev/null +++ b/vendor/README.md @@ -0,0 +1,10 @@ +# Vendored GameCult Rust substrate + +`cultcache-rs`, `cultnet-rs`, and `cultmesh-rs` are copied together from Odin +commit `d34cb7e914e017e376d6f5fa98d464659baf1d73`. They are one compatible +protocol generation and must be updated as a set. Ghostlight vendors the set so +an immutable Starfire release can be rebuilt from its own exact Git commit. + +The older CultCache revision named `cultcache-legacy` remains confined to the +campaign persistence adapter until campaign stores are migrated. It does not +own CultMesh documents or publication. diff --git a/vendor/cultcache-rs/.gitignore b/vendor/cultcache-rs/.gitignore new file mode 100644 index 0000000..96ef6c0 --- /dev/null +++ b/vendor/cultcache-rs/.gitignore @@ -0,0 +1,2 @@ +/target +Cargo.lock diff --git a/vendor/cultcache-rs/Cargo.toml b/vendor/cultcache-rs/Cargo.toml new file mode 100644 index 0000000..3b4a1d6 --- /dev/null +++ b/vendor/cultcache-rs/Cargo.toml @@ -0,0 +1,24 @@ +[package] +name = "cultcache-rs" +version = "0.1.0" +edition = "2024" +publish = false + +[lib] +name = "cultcache_rs" +path = "src/lib.rs" + +[dependencies] +anyhow = "1" +chrono = { version = "0.4", features = ["serde"] } +cultcache-rs-derive = { path = "cultcache-rs-derive" } +fs2 = "0.4" +rmp-serde = "1.3" +serde = { version = "1", features = ["derive"] } +serde_bytes = "0.11" +serde_json = "1" +uuid = { version = "1", features = ["v4"] } + +[dev-dependencies] +pretty_assertions = "1.4" +tempfile = "3" diff --git a/vendor/cultcache-rs/README.md b/vendor/cultcache-rs/README.md new file mode 100644 index 0000000..b21c324 --- /dev/null +++ b/vendor/cultcache-rs/README.md @@ -0,0 +1,332 @@ +# CultCache Rust + +`cultcache-rs` is the Rust port of the useful part of GameCult's CultCache: +a polymorphism-aware in-memory cache that remembers through pluggable backing +stores. + +Consumer code should think in domain types: + +```rust +let player = cache.get_required::("player:meta")?; +cache.put("player:meta", &player)?; +``` + +The persistence layer should deal with envelopes, routing, MessagePack payload +bytes, and schema identity. Application code should not paw at loose JSON files +like a sad little bureaucrat with a clipboard. + +## What It Is + +CultCache is a domain cache with persistence adapters. + +- `CultCache` is the query and mutation surface. +- Domain structs implement `DatabaseEntry`. +- Entries are stored behind a `type::key` identity, so multiple entry types + can share a logical key without colliding. +- Each payload is encoded directly from the known `DatabaseEntry` type into + MessagePack bytes. +- Backing stores are adapters, not the public data model. +- Writes persist to the resolved backing store before the in-memory cache is + updated. +- Type-specific backing stores beat generic backing stores. +- `SingleFileMessagePackBackingStore` is the first concrete store and guards + file access with a sidecar lock file. + +This is not an ORM, not a database, and not distributed consensus in a novelty +hat. If multiple processes write the same backing file, use an external lock or +a coordinator. + +## Current API + +```rust +use cultcache_rs::{CultCache, DatabaseEntry, SingleFileMessagePackBackingStore}; + +#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] +#[cultcache(type = "settings")] +struct Settings { + #[cultcache(key = 0)] + theme: String, + + #[cultcache(key = 1, default)] + retries: u32, +} + +let mut cache = CultCache::new(); +cache.register_entry_type::()?; +cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new("cache.cc")); +cache.pull_all_backing_stores()?; + +cache.put("app", &Settings { + theme: "ash".to_string(), + retries: 3, +})?; + +let settings = cache.get_required::("app")?; +# Ok::<(), anyhow::Error>(()) +``` + +For a closed set of entries, generate a registry instead of repeating yourself: + +```rust +use cultcache_rs::cultcache_registry; + +cultcache_registry!(GameCultEntries { + Settings, + PlayerData, +}); + +let mut cache = CultCache::new(); +cache.register_registry(GameCultEntries)?; +``` + +The important part is that callers retrieve domain values directly: + +```rust +let settings: Settings = cache.get_required("app")?; +let all_settings: Vec = cache.get_all()?; +``` + +The cache is the ergonomic surface. The backing store is the memory prosthetic. + +## How This Maps From Original CultCache + +The original C# CultCache relies on runtime reflection: + +- cacheable models inherit from `DatabaseEntry` +- the cache scans child classes at startup +- `Get(id)` returns a `T` +- optional `INamedEntry` enables name lookup +- optional field/property indexes are registered by member name +- backing stores pull/push/delete `DatabaseEntry` values + +Rust does not have C#-style assembly scanning or runtime subclass discovery. +The closest honest Rust translation is: + +- domain structs implement a marker trait, `DatabaseEntry` +- the derive macro generates a positional array formatter from explicit integer + field slots +- the envelope carries the polymorphic type discriminator +- unknown persisted type ids fail closed instead of constructing arbitrary + runtime types +- a generated registry should eventually replace repetitive manual + registration + +Manual `register_entry_type::()` is still accepted, but entry identity no +longer needs a hand-written impl: `#[derive(DatabaseEntry)]` declares it beside +the domain type. `cultcache_registry!` provides the current generated resolver +surface for a closed entry set. + +## Intended Rust Ergonomics + +The target user-facing shape should be: + +```rust +#[derive(Clone, DatabaseEntry)] +#[cultcache(type = "player")] +pub struct PlayerData { + #[cultcache(key = 0)] + pub id: String, + + #[cultcache(key = 1)] + pub name: String, + + #[cultcache(key = 2)] + pub faction: String, +} + +let mut cache = CultCache::builder() + .with_generated_entries(game_entries()) + .with_generic_store(SingleFileMessagePackBackingStore::new("cache.cc")) + .build()?; + +cache.pull_all_backing_stores()?; +let player = cache.get_required::("player:ari")?; +``` + +The current `cultcache_registry!` macro is deliberately simple. The remaining +ergonomic endpoint is automatic inventory or build-script generation so users +do not have to maintain the registry list by hand. + +The registry is the Rust equivalent of C# reflection and MessagePack resolver +setup. It should know: + +- entry type id +- generated MessagePack/serde formatter path +- Rust type name / schema name +- optional store domain route +- optional name key extractor +- optional secondary indexes +- optional global singleton marker + +In other words: code generation should restore the original CultCache feeling +without pretending Rust has runtime reflection hiding under the floorboards. + +## Current Surface + +- `CultCache::new` +- `register_entry_type::` +- `add_generic_backing_store` +- `add_backing_store` +- `pull_all_backing_stores` +- `get::` +- `get_required::` +- `get_envelope::` +- `get_required_envelope::` +- `get_all::` +- `put::` +- `put_envelope::` +- `update::` +- `delete::` +- `snapshot` +- `SingleFileMessagePackBackingStore` + +## Backing Store Routing + +Generic store: + +```rust +cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new("cache.cc")); +``` + +Type-specific store: + +```rust +cache.add_backing_store( + SingleFileMessagePackBackingStore::new("players.cc"), + ["player"], +); +``` + +When writing a `PlayerData`, the cache checks type-specific stores first. If none +match, it writes to the first generic store. Later matching stores are mirrors. + +This mirrors the C# behavior: + +- specific domain stores own their domain +- the first generic store is the primary generic write target +- later generic stores mirror writes +- this is not multi-master + +## Persistence Semantics + +`put` persists before mutating the in-memory cache. If persistence fails, the +cache does not pretend the write succeeded. + +The envelope is MessagePack, and the payload inside each envelope is also raw +MessagePack bytes encoded from the registered concrete `DatabaseEntry` type. +That avoids the old bootstrap path where payloads were normalized through +`serde_json::Value`. + +For bit-compatible neighbors, that also enables a real fast lane: + +- `get_envelope::()` exports the canonical persisted bytes for a typed entry +- `put_envelope::()` ingests the same envelope into another cache instance + without re-encoding the payload first + +It still decodes once for validation and typed reads. We are not pretending one +`Vec` became metaphysically zero-copy because we believed in it harder. But +the stupid decode/re-encode loop is gone. + +The `DatabaseEntry` derive does not trust Rust source field order as the durable +schema. Every persisted member must declare a stable integer slot: + +```rust +#[derive(Clone, DatabaseEntry)] +#[cultcache(type = "player")] +pub struct PlayerData { + #[cultcache(key = 0)] + pub id: String, + + #[cultcache(key = 1)] + pub name: String, + + #[cultcache(key = 2, default)] + pub level: u32, +} +``` + +The derive emits a tuple/array formatter. Gaps serialize as nil. Missing fields +marked `default` use `Default::default()` when older payloads are read. Deleted +field slots should stay reserved until an explicit store migration rewrites the +data. + +The single-file MessagePack store rewrites an atomic snapshot. That is a sane +starting point for small typed state surfaces, settings, Epiphany agent memory, +heartbeat state, and other compact control-plane data. Large corpora should use +a sharded store or a real database instead of asking one file to become a +warehouse and then acting wounded when physics invoices us. + +The single-file store uses a sidecar lock file for shared reads and exclusive +writes. That protects ordinary multi-process access to the same file. It is +still not a multi-master replication protocol, and it is not a substitute for a +coordinator when higher-level write ordering matters. + +## Near-Term Ergonomic Improvements + +1. **Derive macro** + - `#[derive(DatabaseEntry)]` + - `#[cultcache(type = "...")]` + - `#[cultcache(key = N)]` on every persisted field + - tuple/array formatter generation landed + - optional `#[cultcache(name)]`, `#[cultcache(index)]`, and + `#[cultcache(global)]` are still future work + +2. **Generated registry** + - a `CultCacheRegistry` trait + - `cache.register_registry(GameCultEntries)` + - basic macro registry landed + - automatic inventory/build-script generation and store routes are future work + +3. **Name and index lookups** + - `cache.get_by_name::("Potion")` + - `cache.get_by_index::("faction", "Lucent")` + - generated extractors instead of reflection strings + +4. **Schema/version metadata** + - schema version in the envelope or payload metadata + - explicit migration hooks + - refusal on unknown persisted entry types unless a migration/resolver is + installed + +5. **Projection helpers** + - JSON projection for review and git diffs + - vector stripping / large-field elision for agent memory surfaces + +## Why Not Skip Registration Immediately? + +Rust can only deserialize polymorphic data into concrete types if something +maps the persisted `type` discriminator to the Rust type. In C#, reflection and +MessagePack resolvers can discover a closed `DatabaseEntry` inheritance tree at +runtime and route it through known formatters. In Rust, that map has to come from +somewhere: + +- explicit registration +- a generated registry +- a macro inventory crate +- a hand-written resolver + +Explicit registration is the simplest honest implementation. Generated registry +is the ergonomic destination. Hand-written resolver tables are the punishment +we give ourselves if we get lazy. + +## Security Model + +CultCache should never parse arbitrary structured data into arbitrary runtime +types. It only accepts persisted envelopes whose `type` discriminator resolves +to a known `DatabaseEntry` type registered in the cache or generated registry. + +That is the Rust version of the original trick: + +- C# refuses to store objects outside the `DatabaseEntry` root type. +- Runtime-visible `DatabaseEntry` subclasses get dedicated formatters. +- Unknown or unregistered types are rejected. +- MessagePack payload bytes deserialize through known concrete formatters, not + an open-world type loader or generic structured-value bridge. + +The derive/registry work should preserve that shape. Its job is to remove +manual registration ceremony, not to loosen the closed-world boundary. + +## License + +Private GameCult infrastructure for now. Public packaging can wait until the +API grows enough teeth to deserve strangers. diff --git a/vendor/cultcache-rs/cultcache-rs-derive/Cargo.toml b/vendor/cultcache-rs/cultcache-rs-derive/Cargo.toml new file mode 100644 index 0000000..74d52a4 --- /dev/null +++ b/vendor/cultcache-rs/cultcache-rs-derive/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "cultcache-rs-derive" +version = "0.1.0" +edition = "2024" +publish = false + +[lib] +proc-macro = true + +[dependencies] +proc-macro2 = "1" +quote = "1" +syn = { version = "2", features = ["derive", "parsing"] } diff --git a/vendor/cultcache-rs/cultcache-rs-derive/src/lib.rs b/vendor/cultcache-rs/cultcache-rs-derive/src/lib.rs new file mode 100644 index 0000000..f05a23f --- /dev/null +++ b/vendor/cultcache-rs/cultcache-rs-derive/src/lib.rs @@ -0,0 +1,243 @@ +use proc_macro::TokenStream; +use quote::format_ident; +use quote::quote; +use syn::Data; +use syn::DeriveInput; +use syn::Fields; +use syn::LitInt; +use syn::LitStr; +use syn::Type; +use syn::parse_macro_input; + +#[proc_macro_derive(DatabaseEntry, attributes(cultcache))] +pub fn derive_database_entry(input: TokenStream) -> TokenStream { + let input = parse_macro_input!(input as DeriveInput); + let ident = input.ident.clone(); + let mut entry_type: Option = None; + let mut schema_name: Option = None; + + for attribute in input + .attrs + .iter() + .filter(|attr| attr.path().is_ident("cultcache")) + { + let parse_result = attribute.parse_nested_meta(|meta| { + if meta.path.is_ident("type") { + entry_type = Some(meta.value()?.parse()?); + Ok(()) + } else if meta.path.is_ident("schema") { + schema_name = Some(meta.value()?.parse()?); + Ok(()) + } else { + Err(meta.error("unsupported cultcache attribute")) + } + }); + if let Err(error) = parse_result { + return error.to_compile_error().into(); + } + } + + let Some(entry_type) = entry_type else { + return syn::Error::new_spanned( + ident, + "DatabaseEntry derive requires #[cultcache(type = \"...\")]", + ) + .to_compile_error() + .into(); + }; + let schema_name = schema_name.unwrap_or_else(|| LitStr::new(&ident.to_string(), ident.span())); + + let fields = match input.data { + Data::Struct(data) => match data.fields { + Fields::Named(fields) => fields.named, + _ => { + return syn::Error::new_spanned( + ident, + "DatabaseEntry derive requires a named struct", + ) + .to_compile_error() + .into(); + } + }, + _ => { + return syn::Error::new_spanned(ident, "DatabaseEntry derive requires a struct") + .to_compile_error() + .into(); + } + }; + + let mut slots: Vec = Vec::new(); + for field in fields { + let Some(field_ident) = field.ident else { + return syn::Error::new_spanned(field.ty, "DatabaseEntry derive requires named fields") + .to_compile_error() + .into(); + }; + let mut key: Option = None; + let mut default = false; + for attribute in field + .attrs + .iter() + .filter(|attr| attr.path().is_ident("cultcache")) + { + let parse_result = attribute.parse_nested_meta(|meta| { + if meta.path.is_ident("key") { + let value: LitInt = meta.value()?.parse()?; + key = Some(value.base10_parse()?); + Ok(()) + } else if meta.path.is_ident("default") { + default = true; + Ok(()) + } else { + Err(meta.error("unsupported field cultcache attribute")) + } + }); + if let Err(error) = parse_result { + return error.to_compile_error().into(); + } + } + let Some(key) = key else { + return syn::Error::new_spanned( + field_ident, + "DatabaseEntry fields require #[cultcache(key = N)]", + ) + .to_compile_error() + .into(); + }; + if slots.iter().any(|slot| slot.key == key) { + return syn::Error::new_spanned( + field_ident, + format!("duplicate DatabaseEntry slot {key}"), + ) + .to_compile_error() + .into(); + } + slots.push(CultCacheSlot { + key, + ident: field_ident, + ty: field.ty, + default, + }); + } + slots.sort_by_key(|slot| slot.key); + let max_slot = slots.iter().map(|slot| slot.key).max().unwrap_or(0); + + let serialize_elements = (0..=max_slot).map(|slot| { + if let Some(field) = slots.iter().find(|field| field.key == slot) { + let field_ident = &field.ident; + quote! { + tuple.serialize_element(&self.#field_ident)?; + } + } else { + quote! { + tuple.serialize_element(&())?; + } + } + }); + + let option_declarations = slots.iter().map(|field| { + let variable = format_ident!("slot_{}", field.key); + let ty = &field.ty; + quote! { + let mut #variable: ::std::option::Option<#ty> = ::std::option::Option::None; + } + }); + + let deserialize_match_arms = (0..=max_slot).map(|slot| { + if let Some(field) = slots.iter().find(|field| field.key == slot) { + let variable = format_ident!("slot_{}", field.key); + let ty = &field.ty; + quote! { + #slot => { + #variable = seq.next_element::<#ty>()?; + } + } + } else { + quote! { + #slot => { + let _ = seq.next_element::<::serde::de::IgnoredAny>()?; + } + } + } + }); + + let build_fields = slots.iter().map(|field| { + let field_ident = &field.ident; + let variable = format_ident!("slot_{}", field.key); + if field.default { + quote! { + #field_ident: #variable.unwrap_or_default() + } + } else { + let field_name = field_ident.to_string(); + quote! { + #field_ident: #variable.ok_or_else(|| ::serde::de::Error::missing_field(#field_name))? + } + } + }); + + quote! { + impl ::cultcache_rs::DatabaseEntry for #ident { + const TYPE: &'static str = #entry_type; + const SCHEMA_NAME: &'static str = #schema_name; + } + + impl ::serde::Serialize for #ident { + fn serialize(&self, serializer: S) -> ::std::result::Result + where + S: ::serde::Serializer, + { + use ::serde::ser::SerializeTuple; + let mut tuple = serializer.serialize_tuple(#max_slot + 1)?; + #(#serialize_elements)* + tuple.end() + } + } + + impl<'de> ::serde::Deserialize<'de> for #ident { + fn deserialize(deserializer: D) -> ::std::result::Result + where + D: ::serde::Deserializer<'de>, + { + struct CultCacheVisitor; + + impl<'de> ::serde::de::Visitor<'de> for CultCacheVisitor { + type Value = #ident; + + fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + formatter.write_str(concat!("a CultCache array for ", stringify!(#ident))) + } + + fn visit_seq(self, mut seq: A) -> ::std::result::Result + where + A: ::serde::de::SeqAccess<'de>, + { + #(#option_declarations)* + let mut index = 0usize; + while index <= #max_slot { + match index { + #(#deserialize_match_arms)* + _ => unreachable!(), + } + index += 1; + } + while let ::std::option::Option::Some(_) = seq.next_element::<::serde::de::IgnoredAny>()? {} + Ok(#ident { + #(#build_fields),* + }) + } + } + + deserializer.deserialize_tuple(#max_slot + 1, CultCacheVisitor) + } + } + } + .into() +} + +struct CultCacheSlot { + key: usize, + ident: syn::Ident, + ty: Type, + default: bool, +} diff --git a/vendor/cultcache-rs/examples/cultcache_interop.rs b/vendor/cultcache-rs/examples/cultcache_interop.rs new file mode 100644 index 0000000..4049acf --- /dev/null +++ b/vendor/cultcache-rs/examples/cultcache_interop.rs @@ -0,0 +1,121 @@ +use anyhow::Result; +use anyhow::anyhow; +use cultcache_rs::CultCache; +use cultcache_rs::DatabaseEntry; +use cultcache_rs::SingleFileMessagePackBackingStore; +use serde_json::json; +use std::collections::BTreeMap; + +const INTEROP_TYPE: &str = "cultcache.interop-note"; +const INTEROP_SCHEMA_VERSION: &str = "cultcache.interop_note.v1"; + +#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] +#[cultcache(type = "cultcache.interop-note", schema = "CultCacheInteropNote")] +struct CultCacheInteropNote { + #[cultcache(key = 0)] + schema_version: String, + #[cultcache(key = 1)] + document_id: String, + #[cultcache(key = 2)] + author_runtime_id: String, + #[cultcache(key = 3)] + title: String, + #[cultcache(key = 4)] + body: String, + #[cultcache(key = 5, default)] + tags: Vec, +} + +fn main() -> Result<()> { + let mut args = std::env::args().skip(1); + let mode = args + .next() + .ok_or_else(|| anyhow!("expected mode: write | read"))?; + let options = parse_args(args.collect()); + let file = require_arg(&options, "file")?; + + match mode.as_str() { + "write" => write_note(file, require_arg(&options, "runtime-id")?)?, + "read" => read_note(file)?, + _ => return Err(anyhow!("unknown mode {mode}")), + } + Ok(()) +} + +fn write_note(file: &str, runtime_id: &str) -> Result<()> { + let mut cache = build_cache(file)?; + cache.pull_all_backing_stores()?; + let note = CultCacheInteropNote { + schema_version: INTEROP_SCHEMA_VERSION.to_string(), + document_id: format!("note:{runtime_id}"), + author_runtime_id: runtime_id.to_string(), + title: format!("{runtime_id} wrote a CultCache note"), + body: "The v1 store format is the contract.".to_string(), + tags: vec![ + runtime_id.to_string(), + "rust".to_string(), + "interop".to_string(), + ], + }; + cache.put(¬e.document_id, ¬e)?; + print_note(¬e) +} + +fn read_note(file: &str) -> Result<()> { + let mut cache = build_cache(file)?; + cache.pull_all_backing_stores()?; + let notes = cache.get_all::()?; + let note = notes + .first() + .ok_or_else(|| anyhow!("no {INTEROP_TYPE} records found"))?; + print_note(note) +} + +fn build_cache(file: &str) -> Result { + let mut cache = CultCache::new(); + cache.register_entry_type::()?; + cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(file)); + Ok(cache) +} + +fn print_note(note: &CultCacheInteropNote) -> Result<()> { + println!( + "{}", + serde_json::to_string(&json!({ + "schemaVersion": note.schema_version, + "documentId": note.document_id, + "authorRuntimeId": note.author_runtime_id, + "title": note.title, + "body": note.body, + "tags": note.tags, + }))? + ); + Ok(()) +} + +fn parse_args(args: Vec) -> BTreeMap { + let mut parsed = BTreeMap::new(); + let mut index = 0; + while index < args.len() { + let token = &args[index]; + if !token.starts_with("--") { + index += 1; + continue; + } + let name = token.trim_start_matches("--").to_string(); + let value = args + .get(index + 1) + .cloned() + .unwrap_or_else(|| panic!("missing value for --{name}")); + parsed.insert(name, value); + index += 2; + } + parsed +} + +fn require_arg<'a>(options: &'a BTreeMap, name: &str) -> Result<&'a str> { + options + .get(name) + .map(String::as_str) + .ok_or_else(|| anyhow!("missing required argument --{name}")) +} diff --git a/vendor/cultcache-rs/src/lib.rs b/vendor/cultcache-rs/src/lib.rs new file mode 100644 index 0000000..7e654b9 --- /dev/null +++ b/vendor/cultcache-rs/src/lib.rs @@ -0,0 +1,919 @@ +use anyhow::Context; +use anyhow::Result; +use anyhow::anyhow; +use serde::Serialize; +use serde::de::DeserializeOwned; +use std::collections::BTreeMap; +use std::collections::BTreeSet; +use std::fs; +use std::fs::File; +use std::fs::OpenOptions; +use std::path::Path; +use std::path::PathBuf; + +extern crate self as cultcache_rs; + +pub use cultcache_rs_derive::DatabaseEntry; + +pub trait DatabaseEntry: Serialize + DeserializeOwned + Clone + Send + 'static { + const TYPE: &'static str; + const SCHEMA_NAME: &'static str = "DatabaseEntry"; +} + +pub trait CultCacheRegistry { + fn register_entries(&self, cache: &mut CultCache) -> Result<()>; +} + +#[macro_export] +macro_rules! cultcache_registry { + ($name:ident { $($entry:ty),* $(,)? }) => { + #[derive(Clone, Copy, Debug, Default)] + pub struct $name; + + impl $crate::CultCacheRegistry for $name { + fn register_entries(&self, cache: &mut $crate::CultCache) -> ::anyhow::Result<()> { + $( + cache.register_entry_type::<$entry>()?; + )* + Ok(()) + } + } + }; +} + +#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct CultCacheEnvelope { + pub key: String, + #[serde(rename = "type")] + pub r#type: String, + #[serde(with = "serde_bytes")] + pub payload: Vec, + pub stored_at: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub schema_id: Option, +} + +#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] +struct PersistedStoreSnapshot( + String, + Vec, + Vec, +); + +#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] +struct PersistedSchemaCatalogEntry( + String, + String, + String, + String, + String, + Vec, + Vec, +); + +#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] +struct PersistedSchemaCatalogMember( + u32, + String, + String, + bool, + bool, + Option, + bool, + Option, +); + +#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)] +struct PersistedRecord( + String, + String, + String, + #[serde(with = "serde_bytes")] Vec, +); + +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub struct PushAllOptions { + pub soft: bool, +} + +pub trait CacheBackingStore: Send { + fn pull_all(&self) -> Result>; + fn push(&mut self, entry: &CultCacheEnvelope) -> Result<()>; + fn delete(&mut self, entry: &CultCacheEnvelope) -> Result<()>; + + fn push_all(&mut self, entries: &[CultCacheEnvelope], _options: PushAllOptions) -> Result<()> { + let existing = self.pull_all()?; + for entry in existing { + self.delete(&entry)?; + } + for entry in entries { + self.push(entry)?; + } + Ok(()) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct SingleFileMessagePackBackingStore { + path: PathBuf, +} + +impl SingleFileMessagePackBackingStore { + pub fn new(path: impl Into) -> Self { + Self { path: path.into() } + } + + pub fn path(&self) -> &Path { + &self.path + } + + fn read_all_unlocked(&self) -> Result> { + if !self.path.exists() { + return Ok(Vec::new()); + } + let bytes = fs::read(&self.path) + .with_context(|| format!("failed to read {}", self.path.display()))?; + if bytes.is_empty() { + return Ok(Vec::new()); + } + decode_store_snapshot(&bytes) + .or_else(|_| rmp_serde::from_slice(&bytes)) + .with_context(|| format!("failed to decode MessagePack {}", self.path.display())) + } + + fn write_all_unlocked(&self, entries: &[CultCacheEnvelope]) -> Result<()> { + if let Some(parent) = self.path.parent() { + fs::create_dir_all(parent) + .with_context(|| format!("failed to create {}", parent.display()))?; + } + let bytes = rmp_serde::to_vec(&encode_store_snapshot(entries)) + .context("failed to encode MessagePack")?; + let tmp_path = temporary_path_for(&self.path); + fs::write(&tmp_path, bytes) + .with_context(|| format!("failed to write {}", tmp_path.display()))?; + if self.path.exists() { + fs::remove_file(&self.path) + .with_context(|| format!("failed to replace {}", self.path.display()))?; + } + fs::rename(&tmp_path, &self.path).with_context(|| { + format!( + "failed to move {} to {}", + tmp_path.display(), + self.path.display() + ) + })?; + Ok(()) + } + + fn with_shared_lock(&self, action: impl FnOnce() -> Result) -> Result { + let lock = self.open_lock_file()?; + fs2::FileExt::lock_shared(&lock) + .with_context(|| format!("failed to lock {}", self.lock_path().display()))?; + let result = action(); + fs2::FileExt::unlock(&lock) + .with_context(|| format!("failed to unlock {}", self.lock_path().display()))?; + result + } + + fn with_exclusive_lock(&self, action: impl FnOnce() -> Result) -> Result { + let lock = self.open_lock_file()?; + fs2::FileExt::lock_exclusive(&lock) + .with_context(|| format!("failed to lock {}", self.lock_path().display()))?; + let result = action(); + fs2::FileExt::unlock(&lock) + .with_context(|| format!("failed to unlock {}", self.lock_path().display()))?; + result + } + + fn open_lock_file(&self) -> Result { + let lock_path = self.lock_path(); + if let Some(parent) = lock_path.parent() { + fs::create_dir_all(parent) + .with_context(|| format!("failed to create {}", parent.display()))?; + } + OpenOptions::new() + .create(true) + .read(true) + .truncate(false) + .write(true) + .open(&lock_path) + .with_context(|| format!("failed to open {}", lock_path.display())) + } + + fn lock_path(&self) -> PathBuf { + let mut lock_name = self + .path + .file_name() + .map(|value| value.to_os_string()) + .unwrap_or_else(|| "cultcache.cc".into()); + lock_name.push(".lock"); + self.path.with_file_name(lock_name) + } +} + +impl CacheBackingStore for SingleFileMessagePackBackingStore { + fn pull_all(&self) -> Result> { + self.with_shared_lock(|| self.read_all_unlocked()) + } + + fn push(&mut self, entry: &CultCacheEnvelope) -> Result<()> { + self.with_exclusive_lock(|| { + let mut entries = self.read_all_unlocked()?; + entries.retain(|candidate| entry_id(candidate) != entry_id(entry)); + entries.push(entry.clone()); + entries.sort_by_key(entry_id); + self.write_all_unlocked(&entries) + }) + } + + fn delete(&mut self, entry: &CultCacheEnvelope) -> Result<()> { + self.with_exclusive_lock(|| { + let mut entries = self.read_all_unlocked()?; + entries.retain(|candidate| entry_id(candidate) != entry_id(entry)); + self.write_all_unlocked(&entries) + }) + } + + fn push_all(&mut self, entries: &[CultCacheEnvelope], _options: PushAllOptions) -> Result<()> { + self.with_exclusive_lock(|| { + let mut entries = entries.to_vec(); + entries.sort_by_key(entry_id); + self.write_all_unlocked(&entries) + }) + } +} + +struct CultCacheStoreRegistration { + store: Box, + types: BTreeSet, +} + +pub struct CultCache { + definitions: BTreeMap, + entries: BTreeMap, + stores: Vec, +} + +impl CultCache { + pub fn new() -> Self { + Self { + definitions: BTreeMap::new(), + entries: BTreeMap::new(), + stores: Vec::new(), + } + } + + pub fn register_entry_type(&mut self) -> Result<()> { + if T::TYPE.trim().is_empty() { + return Err(anyhow!( + "CultCache entry types must declare a non-empty type" + )); + } + if let Some(existing_schema) = self.definitions.get(T::TYPE) + && *existing_schema != T::SCHEMA_NAME + { + return Err(anyhow!( + "CultCache already has a different definition registered for type {:?}", + T::TYPE + )); + } + self.definitions.insert(T::TYPE.to_string(), T::SCHEMA_NAME); + Ok(()) + } + + pub fn register_document_type(&mut self) -> Result<()> { + self.register_entry_type::() + } + + pub fn register_registry(&mut self, registry: R) -> Result<&mut Self> { + registry.register_entries(self)?; + Ok(self) + } + + pub fn add_backing_store( + &mut self, + store: impl CacheBackingStore + 'static, + types: impl IntoIterator>, + ) { + self.stores.push(CultCacheStoreRegistration { + store: Box::new(store), + types: types.into_iter().map(Into::into).collect(), + }); + } + + pub fn add_generic_backing_store(&mut self, store: impl CacheBackingStore + 'static) { + self.add_backing_store(store, Vec::::new()); + } + + pub fn pull_all_backing_stores(&mut self) -> Result<()> { + self.entries.clear(); + let known_types: BTreeSet = self.definitions.keys().cloned().collect(); + for registration in &mut self.stores { + for entry in registration.store.pull_all()? { + if !known_types.contains(&entry.r#type) { + return Err(anyhow!( + "No schema is registered for persisted entry type {:?}", + entry.r#type + )); + } + self.entries.insert(entry_id(&entry), entry); + } + } + Ok(()) + } + + pub fn get(&self, key: &str) -> Result> { + self.require_entry_type::()?; + let Some(entry) = self.entries.get(&entry_id_parts(T::TYPE, key)) else { + return Ok(None); + }; + let payload = rmp_serde::from_slice(&entry.payload).with_context(|| { + format!( + "failed to decode CultCache entry {:?} at key {:?} as {}", + T::TYPE, + key, + T::SCHEMA_NAME + ) + })?; + Ok(Some(payload)) + } + + pub fn get_required(&self, key: &str) -> Result { + self.get::(key)? + .ok_or_else(|| anyhow!("CultCache has no {:?} entry at key {:?}", T::TYPE, key)) + } + + pub fn get_envelope(&self, key: &str) -> Result> { + self.require_entry_type::()?; + Ok(self.entries.get(&entry_id_parts(T::TYPE, key)).cloned()) + } + + pub fn get_required_envelope(&self, key: &str) -> Result { + self.get_envelope::(key)? + .ok_or_else(|| anyhow!("CultCache has no {:?} envelope at key {:?}", T::TYPE, key)) + } + + pub fn get_all(&self) -> Result> { + self.require_entry_type::()?; + let mut values = Vec::new(); + for entry in self.entries.values() { + if entry.r#type != T::TYPE { + continue; + } + values.push(rmp_serde::from_slice(&entry.payload).with_context(|| { + format!( + "failed to decode CultCache entry {:?} at key {:?} as {}", + T::TYPE, + entry.key, + T::SCHEMA_NAME + ) + })?); + } + Ok(values) + } + + pub fn put(&mut self, key: impl Into, value: &T) -> Result { + self.require_entry_type::()?; + let key = key.into(); + let payload = rmp_serde::to_vec(value).with_context(|| { + format!( + "failed to encode CultCache entry {:?} at key {:?} as {}", + T::TYPE, + key, + T::SCHEMA_NAME + ) + })?; + let parsed: T = rmp_serde::from_slice(&payload).with_context(|| { + format!( + "failed to validate CultCache entry {:?} at key {:?} as {}", + T::TYPE, + key, + T::SCHEMA_NAME + ) + })?; + let entry = CultCacheEnvelope { + key: key.clone(), + r#type: T::TYPE.to_string(), + payload, + stored_at: now_utc_second(), + schema_id: Some(T::TYPE.to_string()), + }; + let route = self.resolve_route_indices(T::TYPE); + let Some(primary_index) = route.first().copied() else { + return Err(anyhow!( + "No backing store is registered for entry type {:?}", + T::TYPE + )); + }; + self.stores[primary_index].store.push(&entry)?; + for mirror_index in route.iter().skip(1).copied() { + self.stores[mirror_index].store.push(&entry)?; + } + self.entries.insert(entry_id(&entry), entry); + Ok(parsed) + } + + pub fn put_envelope(&mut self, entry: CultCacheEnvelope) -> Result { + self.require_entry_type::()?; + if entry.r#type != T::TYPE { + return Err(anyhow!( + "CultCache envelope type {:?} does not match registered Rust type {:?}", + entry.r#type, + T::TYPE + )); + } + if entry.key.trim().is_empty() { + return Err(anyhow!( + "CultCache envelope keys for type {:?} must be non-empty", + T::TYPE + )); + } + if entry.stored_at.trim().is_empty() { + return Err(anyhow!( + "CultCache envelope stored_at for type {:?} must be non-empty", + T::TYPE + )); + } + + let parsed: T = rmp_serde::from_slice(&entry.payload).with_context(|| { + format!( + "failed to validate CultCache envelope {:?} at key {:?} as {}", + T::TYPE, + entry.key, + T::SCHEMA_NAME + ) + })?; + let route = self.resolve_route_indices(T::TYPE); + let Some(primary_index) = route.first().copied() else { + return Err(anyhow!( + "No backing store is registered for entry type {:?}", + T::TYPE + )); + }; + self.stores[primary_index].store.push(&entry)?; + for mirror_index in route.iter().skip(1).copied() { + self.stores[mirror_index].store.push(&entry)?; + } + self.entries.insert(entry_id(&entry), entry); + Ok(parsed) + } + + pub fn put_raw_envelope(&mut self, entry: CultCacheEnvelope) -> Result<()> { + if !self.definitions.contains_key(&entry.r#type) { + return Err(anyhow!( + "No entry type registered for CultCache envelope type {:?}", + entry.r#type + )); + } + if entry.key.trim().is_empty() { + return Err(anyhow!( + "CultCache envelope keys for type {:?} must be non-empty", + entry.r#type + )); + } + if entry.stored_at.trim().is_empty() { + return Err(anyhow!( + "CultCache envelope stored_at for type {:?} must be non-empty", + entry.r#type + )); + } + let route = self.resolve_route_indices(&entry.r#type); + let Some(primary_index) = route.first().copied() else { + return Err(anyhow!( + "No backing store is registered for entry type {:?}", + entry.r#type + )); + }; + self.stores[primary_index].store.push(&entry)?; + for mirror_index in route.iter().skip(1).copied() { + self.stores[mirror_index].store.push(&entry)?; + } + self.entries.insert(entry_id(&entry), entry); + Ok(()) + } + + pub fn update(&mut self, key: &str, updater: F) -> Result + where + T: DatabaseEntry, + F: FnOnce(Option) -> T, + { + let current = self.get::(key)?; + self.put::(key.to_string(), &updater(current)) + } + + pub fn delete(&mut self, key: &str) -> Result { + self.require_entry_type::()?; + let id = entry_id_parts(T::TYPE, key); + let Some(entry) = self.entries.get(&id).cloned() else { + return Ok(false); + }; + let route = self.resolve_route_indices(T::TYPE); + let Some(primary_index) = route.first().copied() else { + return Err(anyhow!( + "No backing store is registered for entry type {:?}", + T::TYPE + )); + }; + self.stores[primary_index].store.delete(&entry)?; + for mirror_index in route.iter().skip(1).copied() { + self.stores[mirror_index].store.delete(&entry)?; + } + self.entries.remove(&id); + Ok(true) + } + + pub fn snapshot(&self) -> Vec { + self.entries.values().cloned().collect() + } + + fn require_entry_type(&self) -> Result<()> { + match self.definitions.get(T::TYPE) { + Some(schema_name) if *schema_name == T::SCHEMA_NAME => Ok(()), + _ => Err(anyhow!( + "CultCache entry type {:?} is not registered on this cache instance", + T::TYPE + )), + } + } + + fn resolve_route_indices(&self, type_id: &str) -> Vec { + let type_specific: Vec = self + .stores + .iter() + .enumerate() + .filter_map(|(index, registration)| { + registration.types.contains(type_id).then_some(index) + }) + .collect(); + if !type_specific.is_empty() { + return type_specific; + } + self.stores + .iter() + .enumerate() + .filter_map(|(index, registration)| registration.types.is_empty().then_some(index)) + .collect() + } +} + +impl Default for CultCache { + fn default() -> Self { + Self::new() + } +} + +fn entry_id(entry: &CultCacheEnvelope) -> String { + entry_id_parts(&entry.r#type, &entry.key) +} + +fn entry_id_parts(r#type: &str, key: &str) -> String { + format!("{type}::{key}", type = r#type) +} + +fn now_utc_second() -> String { + chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Secs, true) +} + +fn encode_store_snapshot(entries: &[CultCacheEnvelope]) -> PersistedStoreSnapshot { + let mut schema_names = BTreeMap::::new(); + for entry in entries { + schema_names.insert( + entry + .schema_id + .clone() + .unwrap_or_else(|| entry.r#type.clone()), + entry.r#type.clone(), + ); + } + + let catalog = schema_names + .into_iter() + .map(|(schema_id, document_type)| { + PersistedSchemaCatalogEntry( + schema_id.clone(), + document_type, + format!("{schema_id}.v1"), + schema_id.clone(), + format!( + "{{\"schemaName\":\"{}\",\"schemaVersion\":\"{}.v1\",\"members\":[]}}", + escape_json_string(&schema_id), + escape_json_string(&schema_id) + ), + vec![schema_id], + Vec::new(), + ) + }) + .collect(); + let records = entries + .iter() + .map(|entry| { + PersistedRecord( + entry.key.clone(), + entry + .schema_id + .clone() + .unwrap_or_else(|| entry.r#type.clone()), + entry.stored_at.clone(), + entry.payload.clone(), + ) + }) + .collect(); + + PersistedStoreSnapshot("cultcache.store.v1".to_string(), catalog, records) +} + +fn decode_store_snapshot(bytes: &[u8]) -> Result> { + let snapshot: PersistedStoreSnapshot = + rmp_serde::from_slice(bytes).context("failed to decode CultCache v1 snapshot")?; + if snapshot.0 != "cultcache.store.v1" { + return Err(anyhow!("unsupported CultCache snapshot {}", snapshot.0)); + } + + let catalog = snapshot + .1 + .into_iter() + .map(|entry| (entry.0, entry.1)) + .collect::>(); + snapshot + .2 + .into_iter() + .map(|record| { + let r#type = catalog.get(&record.1).cloned().ok_or_else(|| { + anyhow!( + "CultCache record {:?} references missing schema {:?}", + record.0, + record.1 + ) + })?; + Ok(CultCacheEnvelope { + key: record.0, + r#type, + stored_at: record.2, + payload: record.3, + schema_id: Some(record.1), + }) + }) + .collect() +} + +fn escape_json_string(value: &str) -> String { + value.replace('\\', "\\\\").replace('"', "\\\"") +} + +fn temporary_path_for(path: &Path) -> PathBuf { + let mut file_name = path + .file_name() + .map(|value| value.to_os_string()) + .unwrap_or_else(|| "cultcache.cc".into()); + file_name.push(format!(".{}.tmp", uuid::Uuid::new_v4())); + path.with_file_name(file_name) +} + +#[cfg(test)] +mod tests { + use super::*; + use pretty_assertions::assert_eq; + + #[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] + #[cultcache(type = "settings")] + struct Settings { + #[cultcache(key = 0)] + theme: String, + #[cultcache(key = 1, default)] + retries: u32, + } + + #[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] + #[cultcache(type = "note")] + struct Note { + #[cultcache(key = 0)] + title: String, + #[cultcache(key = 1)] + body: String, + } + + cultcache_registry!(TestEntries { Settings, Note }); + + #[test] + fn familiar_cultcache_flow_persists_and_reloads_typed_documents() -> Result<()> { + let temp = tempfile::tempdir()?; + let store_path = temp.path().join("cache.cc"); + let settings = Settings { + theme: "ash".to_string(), + retries: 3, + }; + + let mut cache = CultCache::new(); + cache.register_entry_type::()?; + cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&store_path)); + cache.pull_all_backing_stores()?; + cache.put("app", &settings)?; + assert_eq!(cache.get_required::("app")?, settings); + + let mut reloaded = CultCache::new(); + reloaded.register_entry_type::()?; + reloaded.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&store_path)); + reloaded.pull_all_backing_stores()?; + assert_eq!(reloaded.get_required::("app")?, settings); + Ok(()) + } + + #[test] + fn entry_identity_is_polymorphic_by_type_and_key() -> Result<()> { + let temp = tempfile::tempdir()?; + let store_path = temp.path().join("cache.cc"); + let mut cache = CultCache::new(); + cache.register_registry(TestEntries)?; + cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&store_path)); + + cache.put( + "shared", + &Settings { + theme: "green".to_string(), + retries: 1, + }, + )?; + cache.put( + "shared", + &Note { + title: "same key".to_string(), + body: "different type".to_string(), + }, + )?; + + assert_eq!(cache.snapshot().len(), 2); + assert_eq!(cache.get_required::("shared")?.title, "same key"); + assert_eq!(cache.get_required::("shared")?.theme, "green"); + Ok(()) + } + + #[test] + fn type_specific_store_routes_before_generic_store() -> Result<()> { + let temp = tempfile::tempdir()?; + let generic_path = temp.path().join("generic.cc"); + let settings_path = temp.path().join("settings.cc"); + let mut cache = CultCache::new(); + cache.register_entry_type::()?; + cache.register_entry_type::()?; + cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&generic_path)); + cache.add_backing_store( + SingleFileMessagePackBackingStore::new(&settings_path), + ["settings"], + ); + + cache.put( + "app", + &Settings { + theme: "ash".to_string(), + retries: 3, + }, + )?; + cache.put( + "memo", + &Note { + title: "hello".to_string(), + body: "world".to_string(), + }, + )?; + + let generic_entries = SingleFileMessagePackBackingStore::new(&generic_path).pull_all()?; + let settings_entries = SingleFileMessagePackBackingStore::new(&settings_path).pull_all()?; + assert_eq!(generic_entries[0].r#type, "note"); + assert_eq!(settings_entries[0].r#type, "settings"); + Ok(()) + } + + #[test] + fn update_and_delete_follow_the_cache_api() -> Result<()> { + let temp = tempfile::tempdir()?; + let store_path = temp.path().join("cache.cc"); + let mut cache = CultCache::new(); + cache.register_entry_type::()?; + cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&store_path)); + + let updated = cache.update::("app", |current| { + let mut current = current.unwrap_or(Settings { + theme: "ash".to_string(), + retries: 0, + }); + current.retries += 1; + current + })?; + assert_eq!(updated.retries, 1); + assert!(cache.delete::("app")?); + assert!(cache.get::("app")?.is_none()); + Ok(()) + } + + #[test] + fn pull_rejects_unregistered_persisted_entry_type() -> Result<()> { + let temp = tempfile::tempdir()?; + let store_path = temp.path().join("cache.cc"); + let mut store = SingleFileMessagePackBackingStore::new(&store_path); + store.push(&CultCacheEnvelope { + key: "unknown".to_string(), + r#type: "unregistered".to_string(), + payload: rmp_serde::to_vec(&1_u8)?, + stored_at: now_utc_second(), + schema_id: Some("unregistered".to_string()), + })?; + + let mut cache = CultCache::new(); + cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&store_path)); + let error = cache.pull_all_backing_stores().unwrap_err(); + assert!( + error + .to_string() + .contains("No schema is registered for persisted entry type") + ); + Ok(()) + } + + #[test] + fn payload_is_binary_messagepack_not_json_value() -> Result<()> { + let temp = tempfile::tempdir()?; + let store_path = temp.path().join("cache.cc"); + let mut cache = CultCache::new(); + cache.register_entry_type::()?; + cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&store_path)); + cache.put( + "app", + &Settings { + theme: "ash".to_string(), + retries: 3, + }, + )?; + + let entry = cache.snapshot().remove(0); + let decoded: Settings = rmp_serde::from_slice(&entry.payload)?; + assert_eq!(decoded.theme, "ash"); + assert!(!entry.payload.is_empty()); + Ok(()) + } + + #[test] + fn corrupted_payload_fails_during_typed_retrieval() -> Result<()> { + let temp = tempfile::tempdir()?; + let store_path = temp.path().join("cache.cc"); + let mut store = SingleFileMessagePackBackingStore::new(&store_path); + store.push(&CultCacheEnvelope { + key: "app".to_string(), + r#type: "settings".to_string(), + payload: vec![0xc1], + stored_at: now_utc_second(), + schema_id: Some("settings".to_string()), + })?; + + let mut cache = CultCache::new(); + cache.register_entry_type::()?; + cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&store_path)); + cache.pull_all_backing_stores()?; + let error = cache.get_required::("app").unwrap_err(); + assert!( + error + .to_string() + .contains("failed to decode CultCache entry") + ); + Ok(()) + } + + #[test] + fn put_envelope_reuses_existing_messagepack_payload() -> Result<()> { + let temp = tempfile::tempdir()?; + let origin_store = temp.path().join("origin.cc"); + let target_store = temp.path().join("target.cc"); + + let mut origin = CultCache::new(); + origin.register_entry_type::()?; + origin.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&origin_store)); + origin.put( + "app", + &Settings { + theme: "ash".to_string(), + retries: 3, + }, + )?; + + let envelope = origin.get_required_envelope::("app")?; + + let mut target = CultCache::new(); + target.register_entry_type::()?; + target.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&target_store)); + let applied = target.put_envelope::(envelope.clone())?; + + assert_eq!( + applied, + Settings { + theme: "ash".to_string(), + retries: 3, + } + ); + assert_eq!(target.get_required::("app")?, applied); + assert_eq!( + target.get_required_envelope::("app")?.payload, + envelope.payload + ); + Ok(()) + } +} diff --git a/vendor/cultmesh-rs/Cargo.lock b/vendor/cultmesh-rs/Cargo.lock new file mode 100644 index 0000000..328295c --- /dev/null +++ b/vendor/cultmesh-rs/Cargo.lock @@ -0,0 +1,1233 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aead" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0" +dependencies = [ + "crypto-common", + "generic-array", +] + +[[package]] +name = "aes" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" +dependencies = [ + "cfg-if", + "cipher", + "cpufeatures", +] + +[[package]] +name = "aes-gcm" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1" +dependencies = [ + "aead", + "aes", + "cipher", + "ctr", + "ghash", + "subtle", +] + +[[package]] +name = "android_system_properties" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" +dependencies = [ + "libc", +] + +[[package]] +name = "anyhow" +version = "1.0.102" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "bitflags" +version = "2.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3" + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "bumpalo" +version = "3.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" + +[[package]] +name = "cc" +version = "1.2.62" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1dce859f0832a7d088c4f1119888ab94ef4b5d6795d1ce05afb7fe159d79f98" +dependencies = [ + "find-msvc-tools", + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" + +[[package]] +name = "chrono" +version = "0.4.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0" +dependencies = [ + "iana-time-zone", + "js-sys", + "num-traits", + "serde", + "wasm-bindgen", + "windows-link", +] + +[[package]] +name = "cipher" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" +dependencies = [ + "crypto-common", + "inout", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array", + "rand_core 0.6.4", + "typenum", +] + +[[package]] +name = "ctr" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835" +dependencies = [ + "cipher", +] + +[[package]] +name = "cultcache-rs" +version = "0.1.0" +dependencies = [ + "anyhow", + "chrono", + "cultcache-rs-derive", + "fs2", + "rmp-serde", + "serde", + "serde_bytes", + "serde_json", + "uuid", +] + +[[package]] +name = "cultcache-rs-derive" +version = "0.1.0" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "cultmesh-rs" +version = "0.1.0" +dependencies = [ + "anyhow", + "cultcache-rs", + "cultnet-rs", + "pretty_assertions", + "rmp-serde", + "serde", + "tempfile", +] + +[[package]] +name = "cultnet-rs" +version = "0.1.0" +dependencies = [ + "aes-gcm", + "anyhow", + "base64", + "chrono", + "cultcache-rs", + "hmac", + "rand", + "rmp-serde", + "rmpv", + "serde", + "serde_bytes", + "serde_json", + "sha2", + "socket2", + "uuid", +] + +[[package]] +name = "diff" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8" + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer", + "crypto-common", + "subtle", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "fastrand" +version = "2.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6" + +[[package]] +name = "find-msvc-tools" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582" + +[[package]] +name = "foldhash" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" + +[[package]] +name = "fs2" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213" +dependencies = [ + "libc", + "winapi", +] + +[[package]] +name = "futures-core" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d" + +[[package]] +name = "futures-task" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393" + +[[package]] +name = "futures-util" +version = "0.3.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6" +dependencies = [ + "futures-core", + "futures-task", + "pin-project-lite", + "slab", +] + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "libc", + "wasi", +] + +[[package]] +name = "getrandom" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" +dependencies = [ + "cfg-if", + "libc", + "r-efi 5.3.0", + "wasip2", +] + +[[package]] +name = "getrandom" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555" +dependencies = [ + "cfg-if", + "libc", + "r-efi 6.0.0", + "wasip2", + "wasip3", +] + +[[package]] +name = "ghash" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1" +dependencies = [ + "opaque-debug", + "polyval", +] + +[[package]] +name = "hashbrown" +version = "0.15.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" +dependencies = [ + "foldhash", +] + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "hmac" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" +dependencies = [ + "digest", +] + +[[package]] +name = "iana-time-zone" +version = "0.1.65" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "log", + "wasm-bindgen", + "windows-core", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + +[[package]] +name = "id-arena" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954" + +[[package]] +name = "indexmap" +version = "2.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" +dependencies = [ + "equivalent", + "hashbrown 0.17.1", + "serde", + "serde_core", +] + +[[package]] +name = "inout" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" +dependencies = [ + "generic-array", +] + +[[package]] +name = "itoa" +version = "1.0.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" + +[[package]] +name = "js-sys" +version = "0.3.99" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "142bc4740e452c1e57ade0cbc129f139c9093e354346f0872ef985f4f5cf5f11" +dependencies = [ + "cfg-if", + "futures-util", + "once_cell", + "wasm-bindgen", +] + +[[package]] +name = "leb128fmt" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" + +[[package]] +name = "libc" +version = "0.2.186" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66" + +[[package]] +name = "linux-raw-sys" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" + +[[package]] +name = "log" +version = "0.4.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "616ec5685824bcc94416c6d4a7a446eea774a31efd7062c8480ba6fd06d7a6e5" + +[[package]] +name = "memchr" +version = "2.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b947ae49db0d222b1dbc6b113ce7248a3fc3a6ca21b696717bfc000ba4484d8" + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "opaque-debug" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "polyval" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25" +dependencies = [ + "cfg-if", + "cpufeatures", + "opaque-debug", + "universal-hash", +] + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "pretty_assertions" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d" +dependencies = [ + "diff", + "yansi", +] + +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn", +] + +[[package]] +name = "proc-macro2" +version = "1.0.106" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "5.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f" + +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + +[[package]] +name = "rand" +version = "0.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea" +dependencies = [ + "rand_chacha", + "rand_core 0.9.5", +] + +[[package]] +name = "rand_chacha" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb" +dependencies = [ + "ppv-lite86", + "rand_core 0.9.5", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.17", +] + +[[package]] +name = "rand_core" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c" +dependencies = [ + "getrandom 0.3.4", +] + +[[package]] +name = "rmp" +version = "0.8.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c" +dependencies = [ + "num-traits", +] + +[[package]] +name = "rmp-serde" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155" +dependencies = [ + "rmp", + "serde", +] + +[[package]] +name = "rmpv" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a4e1d4b9b938a26d2996af33229f0ca0956c652c1375067f0b45291c1df8417" +dependencies = [ + "rmp", + "serde", + "serde_bytes", +] + +[[package]] +name = "rustix" +version = "1.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustversion" +version = "1.0.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" + +[[package]] +name = "semver" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" + +[[package]] +name = "serde" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_bytes" +version = "0.11.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8" +dependencies = [ + "serde", + "serde_core", +] + +[[package]] +name = "serde_core" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.228" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.150" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "socket2" +version = "0.5.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678" +dependencies = [ + "libc", + "windows-sys 0.52.0", +] + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "syn" +version = "2.0.117" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "tempfile" +version = "3.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" +dependencies = [ + "fastrand", + "getrandom 0.4.2", + "once_cell", + "rustix", + "windows-sys 0.61.2", +] + +[[package]] +name = "typenum" +version = "1.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de" + +[[package]] +name = "unicode-ident" +version = "1.0.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" + +[[package]] +name = "unicode-xid" +version = "0.2.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" + +[[package]] +name = "universal-hash" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea" +dependencies = [ + "crypto-common", + "subtle", +] + +[[package]] +name = "uuid" +version = "1.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddd74a9687298c6858e9b88ec8935ec45d22e8fd5e6394fa1bd4e99a87789c76" +dependencies = [ + "getrandom 0.4.2", + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasip2" +version = "1.0.3+wasi-0.2.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6" +dependencies = [ + "wit-bindgen 0.57.1", +] + +[[package]] +name = "wasip3" +version = "0.4.0+wasi-0.3.0-rc-2026-01-06" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5" +dependencies = [ + "wit-bindgen 0.51.0", +] + +[[package]] +name = "wasm-bindgen" +version = "0.2.122" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ed04576f974d2b2fba0f38c51dbc5518011e38c36bf1143164be765528fd409" +dependencies = [ + "cfg-if", + "once_cell", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.122" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "916151b09da36bd82f6615cbf3a419e2f0ba23a03c6160e8e92eb6bd4aa1dec6" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.122" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "299047362ccbfce148b67ab7e73349f77748e00c8296f9542adfad2ad82c5c5e" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.122" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a929b2c61f11ba3e9bc35b50c1f25cb38e0e892c0c231ae2b8cf78d5dad4437" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wasm-encoder" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319" +dependencies = [ + "leb128fmt", + "wasmparser", +] + +[[package]] +name = "wasm-metadata" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909" +dependencies = [ + "anyhow", + "indexmap", + "wasm-encoder", + "wasmparser", +] + +[[package]] +name = "wasmparser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe" +dependencies = [ + "bitflags", + "hashbrown 0.15.5", + "indexmap", + "semver", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" + +[[package]] +name = "windows-core" +version = "0.62.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb" +dependencies = [ + "windows-implement", + "windows-interface", + "windows-link", + "windows-result", + "windows-strings", +] + +[[package]] +name = "windows-implement" +version = "0.60.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-interface" +version = "0.59.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-result" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-strings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "wit-bindgen" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5" +dependencies = [ + "wit-bindgen-rust-macro", +] + +[[package]] +name = "wit-bindgen" +version = "0.57.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" + +[[package]] +name = "wit-bindgen-core" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc" +dependencies = [ + "anyhow", + "heck", + "wit-parser", +] + +[[package]] +name = "wit-bindgen-rust" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21" +dependencies = [ + "anyhow", + "heck", + "indexmap", + "prettyplease", + "syn", + "wasm-metadata", + "wit-bindgen-core", + "wit-component", +] + +[[package]] +name = "wit-bindgen-rust-macro" +version = "0.51.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a" +dependencies = [ + "anyhow", + "prettyplease", + "proc-macro2", + "quote", + "syn", + "wit-bindgen-core", + "wit-bindgen-rust", +] + +[[package]] +name = "wit-component" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2" +dependencies = [ + "anyhow", + "bitflags", + "indexmap", + "log", + "serde", + "serde_derive", + "serde_json", + "wasm-encoder", + "wasm-metadata", + "wasmparser", + "wit-parser", +] + +[[package]] +name = "wit-parser" +version = "0.244.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736" +dependencies = [ + "anyhow", + "id-arena", + "indexmap", + "log", + "semver", + "serde", + "serde_derive", + "serde_json", + "unicode-xid", + "wasmparser", +] + +[[package]] +name = "yansi" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049" + +[[package]] +name = "zerocopy" +version = "0.8.48" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.48" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "zmij" +version = "1.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" diff --git a/vendor/cultmesh-rs/Cargo.toml b/vendor/cultmesh-rs/Cargo.toml new file mode 100644 index 0000000..9a719d3 --- /dev/null +++ b/vendor/cultmesh-rs/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "cultmesh-rs" +version = "0.1.0" +edition = "2024" +publish = false + +[lib] +name = "cultmesh_rs" +path = "src/lib.rs" + +[dependencies] +anyhow = "1" +cultcache-rs = { path = "../cultcache-rs" } +cultnet-rs = { path = "../cultnet-rs" } +serde = { version = "1", features = ["derive"] } + +[dev-dependencies] +pretty_assertions = "1.4.1" +rmp-serde = "1" +tempfile = "3" diff --git a/vendor/cultmesh-rs/src/lib.rs b/vendor/cultmesh-rs/src/lib.rs new file mode 100644 index 0000000..ebcde2c --- /dev/null +++ b/vendor/cultmesh-rs/src/lib.rs @@ -0,0 +1,1277 @@ +use anyhow::{Context, Result}; +use cultcache_rs::CultCache; +use cultcache_rs::CultCacheEnvelope; +use cultcache_rs::DatabaseEntry; +use cultcache_rs::SingleFileMessagePackBackingStore; +use cultnet_rs::CultNetDocumentPutOptions; +use cultnet_rs::CultNetDocumentRegistry; +use cultnet_rs::CultNetRudpSocketTransportConnection; +use cultnet_rs::CultNetRudpSocketTransportOptions; +use cultnet_rs::CultNetWireContract; +use cultnet_rs::decode_cultnet_message_from_slice; +use cultnet_rs::encode_cultnet_message_to_vec; +use serde::Serialize; +use std::collections::BTreeMap; +use std::env; +use std::net::SocketAddr; +use std::net::UdpSocket; +use std::path::Path; +use std::thread; +use std::time::Duration; +use std::time::Instant; + +pub const CULTMESH_RUDP_DOCUMENT_CATALOG_CONNECTION_ID: u32 = 0x0d1d_0002; + +pub trait CultMeshDocumentSet: Clone + Send + Sync + 'static { + fn register_cache(&self, cache: &mut CultCache) -> Result<()>; + fn register_documents(&self, registry: &mut CultNetDocumentRegistry) -> Result<()>; +} + +#[macro_export] +macro_rules! cultmesh_documents { + ($name:ident { $($entry:ty => $schema_version:expr),* $(,)? }) => { + #[derive(Clone, Copy, Debug, Default)] + pub struct $name; + + impl $crate::CultMeshDocumentSet for $name { + fn register_cache( + &self, + cache: &mut cultcache_rs::CultCache, + ) -> ::anyhow::Result<()> { + $( + cache.register_entry_type::<$entry>()?; + )* + Ok(()) + } + + fn register_documents( + &self, + registry: &mut cultnet_rs::CultNetDocumentRegistry, + ) -> ::anyhow::Result<()> { + $( + registry.register( + cultnet_rs::CultNetDocumentBinding::for_entry_with_schema_id::<$entry>( + $schema_version.to_string(), + $schema_version.to_string(), + ), + ); + )* + Ok(()) + } + } + }; +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultMeshNodeOptions { + pub runtime_id: String, + pub pull_on_start: bool, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultMeshRudpDocumentPublishOptions { + pub target: SocketAddr, + pub runtime_id: String, + pub connection_id: u32, + pub connect_timeout: Duration, + pub flush_timeout: Duration, + pub poll_interval: Duration, + pub resend_delay_ms: u64, + pub source_agent_id: Option, + pub source_role: Option, + pub tags: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultMeshRudpSnapshotOptions { + pub target: SocketAddr, + pub runtime_id: String, + pub connection_id: u32, + pub connect_timeout: Duration, + pub response_timeout: Duration, + pub poll_interval: Duration, + pub resend_delay_ms: u64, + pub schema_ids: Option>, + pub record_keys: Option>, +} + +impl CultMeshRudpSnapshotOptions { + pub fn odin(target: SocketAddr, runtime_id: impl Into) -> Self { + Self { + target, + runtime_id: runtime_id.into(), + ..Self::default() + } + } +} + +impl Default for CultMeshRudpSnapshotOptions { + fn default() -> Self { + Self { + target: SocketAddr::from(([0, 0, 0, 0], 0)), + runtime_id: "cultmesh-rudp-snapshot-client".to_string(), + connection_id: CULTMESH_RUDP_DOCUMENT_CATALOG_CONNECTION_ID, + connect_timeout: Duration::from_secs(3), + response_timeout: Duration::from_secs(3), + poll_interval: Duration::from_millis(10), + resend_delay_ms: 50, + schema_ids: None, + record_keys: None, + } + } +} + +impl CultMeshRudpDocumentPublishOptions { + pub fn odin(target: SocketAddr, runtime_id: impl Into) -> Self { + Self { + target, + runtime_id: runtime_id.into(), + ..Self::default() + } + } +} + +impl Default for CultMeshRudpDocumentPublishOptions { + fn default() -> Self { + Self { + target: SocketAddr::from(([0, 0, 0, 0], 0)), + runtime_id: "cultmesh-rudp-document-publisher".to_string(), + connection_id: CULTMESH_RUDP_DOCUMENT_CATALOG_CONNECTION_ID, + connect_timeout: Duration::from_secs(3), + flush_timeout: Duration::from_millis(300), + poll_interval: Duration::from_millis(10), + resend_delay_ms: 50, + source_agent_id: None, + source_role: None, + tags: Vec::new(), + } + } +} + +impl Default for CultMeshNodeOptions { + fn default() -> Self { + Self { + runtime_id: "cultmesh-local".to_string(), + pull_on_start: true, + } + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultMeshRudpEndpoint { + pub host: String, + pub port: u16, + pub addr: SocketAddr, +} + +pub struct CultMeshNode { + runtime_id: String, + cache: CultCache, + documents: CultNetDocumentRegistry, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CultMeshStreamKind { + Audio, + Video, + Tensor, + Bytes, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CultMeshStreamBodyTransport { + SharedMemory, + SharedD3d12Texture, + SharedD3d11Texture, + DmaBuf, + IoSurface, + AHardwareBuffer, + CultCachePage, + InlineBytes, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CultMeshStreamAccess { + Read, + Write, + ReadWrite, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CultMeshStreamCopyBudget { + ZeroCopyTarget, + OneCopyFallback, + OpaqueRuntime, +} + +#[derive(Clone, Debug, PartialEq)] +pub struct CultMeshStreamClock { + pub clock_domain_id: String, + pub source_id: Option, + pub sample_rate: i32, + pub offset_to_verse_time_ns: i64, + pub confidence: f64, + pub evidence_kind: Option, +} + +impl CultMeshStreamClock { + pub fn new(clock_domain_id: impl Into) -> Result { + let clock_domain_id = require_non_empty(clock_domain_id.into(), "clock_domain_id")?; + Ok(Self { + clock_domain_id, + source_id: None, + sample_rate: 0, + offset_to_verse_time_ns: 0, + confidence: 0.0, + evidence_kind: None, + }) + } + + pub fn source_id(mut self, source_id: impl Into) -> Result { + self.source_id = Some(require_non_empty(source_id.into(), "source_id")?); + Ok(self) + } + + pub fn confidence(mut self, confidence: f64) -> Self { + self.confidence = confidence; + self + } + + pub fn evidence_kind(mut self, evidence_kind: impl Into) -> Result { + self.evidence_kind = Some(require_non_empty(evidence_kind.into(), "evidence_kind")?); + Ok(self) + } +} + +#[derive(Clone, Debug, PartialEq)] +pub struct CultMeshStreamDescriptor { + pub stream_id: String, + pub verse_id: String, + pub owner_peer_id: String, + pub kind: CultMeshStreamKind, + pub clock: CultMeshStreamClock, + pub preferred_transports: Vec, + pub label: Option, + pub required_access: CultMeshStreamAccess, + pub max_in_flight_frames: u32, + pub metadata_schema_id: Option, +} + +impl CultMeshStreamDescriptor { + pub fn new( + stream_id: impl Into, + verse_id: impl Into, + owner_peer_id: impl Into, + kind: CultMeshStreamKind, + clock: CultMeshStreamClock, + preferred_transports: Vec, + ) -> Result { + if preferred_transports.is_empty() { + anyhow::bail!("preferred_transports must not be empty"); + } + Ok(Self { + stream_id: require_non_empty(stream_id.into(), "stream_id")?, + verse_id: require_non_empty(verse_id.into(), "verse_id")?, + owner_peer_id: require_non_empty(owner_peer_id.into(), "owner_peer_id")?, + kind, + clock, + preferred_transports, + label: None, + required_access: CultMeshStreamAccess::Read, + max_in_flight_frames: 0, + metadata_schema_id: None, + }) + } + + pub fn label(mut self, label: impl Into) -> Result { + self.label = Some(require_non_empty(label.into(), "label")?); + Ok(self) + } + + pub fn max_in_flight_frames(mut self, max_in_flight_frames: u32) -> Self { + self.max_in_flight_frames = max_in_flight_frames; + self + } + + pub fn metadata_schema_id(mut self, metadata_schema_id: impl Into) -> Result { + self.metadata_schema_id = Some(require_non_empty( + metadata_schema_id.into(), + "metadata_schema_id", + )?); + Ok(self) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultMeshStreamConsumerProfile { + pub peer_id: String, + pub verse_id: String, + pub supported_transports: Vec, + pub accepted_kinds: Vec, + pub max_in_flight_frames: u32, +} + +impl CultMeshStreamConsumerProfile { + pub fn new( + peer_id: impl Into, + verse_id: impl Into, + supported_transports: Vec, + ) -> Result { + if supported_transports.is_empty() { + anyhow::bail!("supported_transports must not be empty"); + } + Ok(Self { + peer_id: require_non_empty(peer_id.into(), "peer_id")?, + verse_id: require_non_empty(verse_id.into(), "verse_id")?, + supported_transports, + accepted_kinds: Vec::new(), + max_in_flight_frames: 0, + }) + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultMeshStreamNegotiation { + pub stream_id: String, + pub producer_peer_id: String, + pub consumer_peer_id: String, + pub transport: CultMeshStreamBodyTransport, + pub access: CultMeshStreamAccess, + pub max_in_flight_frames: u32, + pub copy_budget: CultMeshStreamCopyBudget, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultMeshStreamFrameHandle { + pub stream_id: String, + pub sequence: u64, + pub timestamp_ns: i64, + pub duration_ns: i64, + pub transport: CultMeshStreamBodyTransport, + pub byte_length: usize, + pub resource_key: Option, + pub unavoidable_copy_count: u32, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultMeshSharedMemoryFrameRingStats { + pub stream_id: String, + pub slot_count: usize, + pub slot_byte_length: usize, + pub published_frames: u64, + pub dropped_frames: u64, + pub blocked_writes: u64, + pub latest_sequence: u64, + pub unavoidable_copy_count: u64, +} + +pub struct CultMeshFrameReadLease<'a> { + pub handle: CultMeshStreamFrameHandle, + bytes: &'a [u8], +} + +impl CultMeshFrameReadLease<'_> { + pub fn bytes(&self) -> &[u8] { + self.bytes + } +} + +#[derive(Clone, Debug)] +pub struct CultMeshSharedMemoryFrameRing { + stream_id: String, + slot_byte_length: usize, + slots: Vec)>>, + write_cursor: usize, + latest_slot: Option, + next_sequence: u64, + published_frames: u64, + dropped_frames: u64, + blocked_writes: u64, + unavoidable_copy_count: u64, +} + +impl CultMeshSharedMemoryFrameRing { + pub fn new( + stream_id: impl Into, + slot_count: usize, + slot_byte_length: usize, + ) -> Result { + let stream_id = require_non_empty(stream_id.into(), "stream_id")?; + if slot_count == 0 { + anyhow::bail!("slot_count must be greater than zero"); + } + if slot_byte_length == 0 { + anyhow::bail!("slot_byte_length must be greater than zero"); + } + Ok(Self { + stream_id, + slot_byte_length, + slots: vec![None; slot_count], + write_cursor: 0, + latest_slot: None, + next_sequence: 0, + published_frames: 0, + dropped_frames: 0, + blocked_writes: 0, + unavoidable_copy_count: 0, + }) + } + + pub fn try_publish_copy( + &mut self, + bytes: &[u8], + timestamp_ns: i64, + duration_ns: i64, + ) -> Result> { + if bytes.len() > self.slot_byte_length { + anyhow::bail!("frame byte length exceeds slot size"); + } + if self.slots.is_empty() { + self.blocked_writes += 1; + return Ok(None); + } + + let slot_index = self.write_cursor; + if self.slots[slot_index].is_some() { + self.dropped_frames += 1; + } + let handle = CultMeshStreamFrameHandle { + stream_id: self.stream_id.clone(), + sequence: self.next_sequence, + timestamp_ns, + duration_ns, + transport: CultMeshStreamBodyTransport::SharedMemory, + byte_length: bytes.len(), + resource_key: Some(format!("{}:slot:{slot_index}", self.stream_id)), + unavoidable_copy_count: 1, + }; + self.slots[slot_index] = Some((handle.clone(), bytes.to_vec())); + self.latest_slot = Some(slot_index); + self.write_cursor = (slot_index + 1) % self.slots.len(); + self.next_sequence = self.next_sequence.saturating_add(1); + self.published_frames = self.published_frames.saturating_add(1); + self.unavoidable_copy_count = self.unavoidable_copy_count.saturating_add(1); + Ok(Some(handle)) + } + + pub fn try_acquire_latest_read(&self) -> Option> { + let slot_index = self.latest_slot?; + let (handle, bytes) = self.slots[slot_index].as_ref()?; + Some(CultMeshFrameReadLease { + handle: handle.clone(), + bytes, + }) + } + + pub fn stats(&self) -> CultMeshSharedMemoryFrameRingStats { + let latest_sequence = self + .latest_slot + .and_then(|slot| self.slots[slot].as_ref().map(|(handle, _)| handle.sequence)) + .unwrap_or(0); + CultMeshSharedMemoryFrameRingStats { + stream_id: self.stream_id.clone(), + slot_count: self.slots.len(), + slot_byte_length: self.slot_byte_length, + published_frames: self.published_frames, + dropped_frames: self.dropped_frames, + blocked_writes: self.blocked_writes, + latest_sequence, + unavoidable_copy_count: self.unavoidable_copy_count, + } + } +} + +#[derive(Clone, Debug, Default)] +pub struct CultMeshStreamCatalog { + streams: BTreeMap, + latest_frames: BTreeMap, + rings: BTreeMap, +} + +impl CultMeshStreamCatalog { + pub fn declare(&mut self, stream: CultMeshStreamDescriptor) { + self.streams.insert(stream.stream_id.clone(), stream); + } + + pub fn get(&self, stream_id: &str) -> Option<&CultMeshStreamDescriptor> { + self.streams.get(stream_id) + } + + pub fn streams(&self) -> Vec<&CultMeshStreamDescriptor> { + self.streams.values().collect() + } + + pub fn find( + &self, + verse_id: &str, + kind: Option, + ) -> Vec<&CultMeshStreamDescriptor> { + self.streams + .values() + .filter(|stream| stream.verse_id == verse_id && kind.is_none_or(|k| stream.kind == k)) + .collect() + } + + pub fn negotiate( + &self, + stream_id: &str, + consumer: &CultMeshStreamConsumerProfile, + ) -> Result { + let stream = self + .streams + .get(stream_id) + .ok_or_else(|| anyhow::anyhow!("unknown CultMesh stream '{stream_id}'"))?; + if stream.verse_id != consumer.verse_id { + anyhow::bail!("stream and consumer must belong to the same Verse"); + } + if !consumer.accepted_kinds.is_empty() && !consumer.accepted_kinds.contains(&stream.kind) { + anyhow::bail!("consumer does not accept stream kind"); + } + let transport = stream + .preferred_transports + .iter() + .copied() + .find(|candidate| consumer.supported_transports.contains(candidate)) + .ok_or_else(|| { + anyhow::anyhow!("stream and consumer have no compatible body transport") + })?; + let producer_max = if stream.max_in_flight_frames == 0 { + u32::MAX + } else { + stream.max_in_flight_frames + }; + let consumer_max = if consumer.max_in_flight_frames == 0 { + u32::MAX + } else { + consumer.max_in_flight_frames + }; + Ok(CultMeshStreamNegotiation { + stream_id: stream.stream_id.clone(), + producer_peer_id: stream.owner_peer_id.clone(), + consumer_peer_id: consumer.peer_id.clone(), + transport, + access: stream.required_access, + max_in_flight_frames: producer_max.min(consumer_max), + copy_budget: copy_budget_for(transport), + }) + } + + pub fn create_shared_memory_ring( + &mut self, + stream_id: &str, + slot_count: usize, + slot_byte_length: usize, + ) -> Result<&mut CultMeshSharedMemoryFrameRing> { + if !self.streams.contains_key(stream_id) { + anyhow::bail!("unknown CultMesh stream '{stream_id}'"); + } + self.rings.insert( + stream_id.to_string(), + CultMeshSharedMemoryFrameRing::new(stream_id, slot_count, slot_byte_length)?, + ); + Ok(self + .rings + .get_mut(stream_id) + .expect("ring was inserted for stream")) + } + + pub fn ring(&self, stream_id: &str) -> Option<&CultMeshSharedMemoryFrameRing> { + self.rings.get(stream_id) + } + + pub fn ring_mut(&mut self, stream_id: &str) -> Option<&mut CultMeshSharedMemoryFrameRing> { + self.rings.get_mut(stream_id) + } + + pub fn publish_frame(&mut self, handle: CultMeshStreamFrameHandle) -> Result<()> { + if !self.streams.contains_key(&handle.stream_id) { + anyhow::bail!("unknown CultMesh stream '{}'", handle.stream_id); + } + self.latest_frames.insert(handle.stream_id.clone(), handle); + Ok(()) + } + + pub fn latest_frame(&self, stream_id: &str) -> Option<&CultMeshStreamFrameHandle> { + self.latest_frames.get(stream_id) + } +} + +fn copy_budget_for(transport: CultMeshStreamBodyTransport) -> CultMeshStreamCopyBudget { + match transport { + CultMeshStreamBodyTransport::SharedMemory + | CultMeshStreamBodyTransport::SharedD3d12Texture + | CultMeshStreamBodyTransport::SharedD3d11Texture + | CultMeshStreamBodyTransport::DmaBuf + | CultMeshStreamBodyTransport::IoSurface + | CultMeshStreamBodyTransport::AHardwareBuffer => CultMeshStreamCopyBudget::ZeroCopyTarget, + CultMeshStreamBodyTransport::CultCachePage => CultMeshStreamCopyBudget::OneCopyFallback, + CultMeshStreamBodyTransport::InlineBytes => CultMeshStreamCopyBudget::OpaqueRuntime, + } +} + +fn require_non_empty(value: String, name: &str) -> Result { + if value.trim().is_empty() { + anyhow::bail!("{name} must be non-empty"); + } + Ok(value) +} + +impl CultMeshNode { + pub fn runtime_id(&self) -> &str { + &self.runtime_id + } + + pub fn cache(&self) -> &CultCache { + &self.cache + } + + pub fn documents(&self) -> &CultNetDocumentRegistry { + &self.documents + } + + pub fn get(&self, key: &str) -> Result> { + self.cache.get::(key) + } + + pub fn get_required(&self, key: &str) -> Result { + self.cache.get_required::(key) + } + + pub fn put(&mut self, key: impl Into, value: &T) -> Result { + self.cache.put(key, value) + } + + pub fn pull_all_backing_stores(&mut self) -> Result<()> { + self.cache.pull_all_backing_stores() + } + + pub fn delete(&mut self, key: &str) -> Result { + self.cache.delete::(key) + } + + pub fn flush(&mut self) -> Result<()> { + Ok(()) + } + + pub fn publish_document_to_rudp_catalog( + &self, + key: impl Into, + value: &T, + options: CultMeshRudpDocumentPublishOptions, + ) -> Result<()> + where + T: DatabaseEntry + Serialize, + { + let key = key.into(); + let message = self.documents.create_raw_document_put_message( + format!("{}:{}:{}", options.runtime_id, T::TYPE, key), + key, + value, + CultNetDocumentPutOptions { + source_runtime_id: Some(options.runtime_id.clone()), + source_agent_id: options.source_agent_id.clone(), + source_role: options.source_role.clone(), + tags: if options.tags.is_empty() { + None + } else { + Some(options.tags.clone()) + }, + ..CultNetDocumentPutOptions::default() + }, + )?; + publish_cultnet_message_to_rudp_catalog(&message, options) + } + + pub fn pull_rudp_catalog_snapshot( + &mut self, + options: CultMeshRudpSnapshotOptions, + ) -> Result { + let response = request_raw_snapshot_from_rudp_catalog(options)?; + let cultnet_rs::CultNetMessage::SnapshotResponseRaw { documents, .. } = response else { + anyhow::bail!("expected cultnet.snapshot_response_raw.v0"); + }; + let mut applied = 0usize; + for document in documents { + let Some(document_type) = + registered_document_type_for_schema(&self.documents, &document.schema_id) + else { + continue; + }; + self.cache.put_raw_envelope(CultCacheEnvelope { + key: document.record_key, + r#type: document_type, + payload: document.payload, + stored_at: document.stored_at, + schema_id: Some(document.schema_id), + })?; + applied += 1; + } + Ok(applied) + } +} + +fn registered_document_type_for_schema( + documents: &CultNetDocumentRegistry, + schema_id: &str, +) -> Option { + let normalized = strip_schema_version_suffix(schema_id); + if normalized != schema_id { + return Some(normalized.to_string()); + } + documents + .binding_by_schema_id(schema_id) + .map(|binding| binding.document_type.clone()) + .or_else(|| documents.binding(schema_id).map(|_| schema_id.to_string())) +} + +fn strip_schema_version_suffix(value: &str) -> &str { + let Some((prefix, suffix)) = value.rsplit_once(".v") else { + return value; + }; + if suffix.chars().all(|character| character.is_ascii_digit()) { + prefix + } else { + value + } +} + +fn request_raw_snapshot_from_rudp_catalog( + options: CultMeshRudpSnapshotOptions, +) -> Result { + if options.runtime_id.trim().is_empty() { + anyhow::bail!("runtime_id must be non-empty"); + } + let bind_addr = if options.target.is_ipv4() { + SocketAddr::from(([0, 0, 0, 0], 0)) + } else { + SocketAddr::from(([0, 0, 0, 0, 0, 0, 0, 0], 0)) + }; + let socket = UdpSocket::bind(bind_addr)?; + socket.set_read_timeout(Some(options.poll_interval))?; + let mut client = + CultNetRudpSocketTransportConnection::new(CultNetRudpSocketTransportOptions { + runtime_id: options.runtime_id.clone(), + socket, + mode: cultnet_rs::CultNetRudpSocketMode::Client, + remote_addr: Some(options.target), + connection_id: options.connection_id, + initial_sequence: 1, + resend_delay_ms: options.resend_delay_ms, + transport_id: Some("cultmesh-rudp-snapshot-client".to_string()), + max_payload_bytes: None, + max_fragment_bytes: Some(1200), + max_pending_reliable_packets: None, + media_reliable_expire_after_ms: None, + })?; + client.connect(Vec::new())?; + let connect_deadline = Instant::now() + options.connect_timeout; + while !client.connected() && Instant::now() < connect_deadline { + let _ = client.receive_once()?; + client.poll_resends()?; + thread::sleep(options.poll_interval); + } + if !client.connected() { + anyhow::bail!( + "timed out connecting CultMesh RUDP snapshot client {} to {}", + options.runtime_id, + options.target + ); + } + + let message_id = format!("{}:snapshot:{}", options.runtime_id, unix_millis()); + let request = cultnet_rs::CultNetMessage::SnapshotRequest { + message_id: message_id.clone(), + schema_ids: options.schema_ids, + record_keys: options.record_keys, + }; + let payload = encode_cultnet_message_to_vec(&request, CultNetWireContract::CultNetSchemaV0)?; + client.send("schema", payload)?; + let response_deadline = Instant::now() + options.response_timeout; + let mut snapshot_response = None; + while Instant::now() < response_deadline { + if let Some(frame) = client.receive_once()? { + if frame.channel_id == "schema" { + let message = decode_cultnet_message_from_slice( + &frame.payload, + CultNetWireContract::CultNetSchemaV0, + )?; + match &message { + cultnet_rs::CultNetMessage::SnapshotResponseRaw { + message_id: received, + .. + } if received == &message_id => { + snapshot_response = Some(message); + break; + } + cultnet_rs::CultNetMessage::Error { error } => { + let _ = client.disconnect(b"snapshot-error".to_vec()); + anyhow::bail!("CultMesh RUDP snapshot failed: {error}"); + } + _ => {} + } + } + } + client.poll_resends()?; + thread::sleep(options.poll_interval); + } + if let Some(message) = snapshot_response { + let _ = client.disconnect(b"snapshot-complete".to_vec()); + return Ok(message); + } + let _ = client.disconnect(b"snapshot-timeout".to_vec()); + anyhow::bail!( + "timed out waiting for CultMesh RUDP snapshot from {}", + options.target + ) +} + +fn unix_millis() -> u128 { + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap_or_default() + .as_millis() +} + +fn publish_cultnet_message_to_rudp_catalog( + message: &cultnet_rs::CultNetMessage, + options: CultMeshRudpDocumentPublishOptions, +) -> Result<()> { + if options.runtime_id.trim().is_empty() { + anyhow::bail!("runtime_id must be non-empty"); + } + let bind_addr = if options.target.is_ipv4() { + SocketAddr::from(([0, 0, 0, 0], 0)) + } else { + SocketAddr::from(([0, 0, 0, 0, 0, 0, 0, 0], 0)) + }; + let socket = UdpSocket::bind(bind_addr)?; + socket.set_read_timeout(Some(options.poll_interval))?; + let mut client = + CultNetRudpSocketTransportConnection::new(CultNetRudpSocketTransportOptions { + runtime_id: options.runtime_id.clone(), + socket, + mode: cultnet_rs::CultNetRudpSocketMode::Client, + remote_addr: Some(options.target), + connection_id: options.connection_id, + initial_sequence: 1, + resend_delay_ms: options.resend_delay_ms, + transport_id: Some("cultmesh-rudp-document-publisher".to_string()), + max_payload_bytes: None, + max_fragment_bytes: Some(1200), + max_pending_reliable_packets: None, + media_reliable_expire_after_ms: None, + })?; + client.connect(Vec::new())?; + let connect_deadline = Instant::now() + options.connect_timeout; + while !client.connected() && Instant::now() < connect_deadline { + let _ = client.receive_once()?; + client.poll_resends()?; + thread::sleep(options.poll_interval); + } + if !client.connected() { + client.assume_connected(); + } + + let payload = encode_cultnet_message_to_vec(message, CultNetWireContract::CultNetSchemaV0)?; + client.send("schema", payload)?; + let flush_deadline = Instant::now() + options.flush_timeout; + while Instant::now() < flush_deadline { + let _ = client.receive_once()?; + client.poll_resends()?; + thread::sleep(options.poll_interval); + } + Ok(()) +} + +#[derive(Clone, Copy, Debug, Default)] +pub struct CultMesh; + +impl CultMesh { + pub fn resolve_rudp_endpoint(endpoint: &str) -> Result { + let text = require_non_empty(endpoint.trim().to_string(), "endpoint")?; + if text.starts_with("rudp://") { + return parse_rudp_socket_addr(&text); + } + if text.starts_with("cultmesh://") { + let resolved = default_cultmesh_rudp_endpoint_resolver(&text)?.ok_or_else(|| { + anyhow::anyhow!("CultMesh URI {text} did not resolve to a RUDP endpoint") + })?; + return parse_rudp_socket_addr(&resolved); + } + parse_socket_addr(&text) + } + + pub fn create_node( + store_path: impl AsRef, + documents: D, + options: CultMeshNodeOptions, + ) -> Result + where + D: CultMeshDocumentSet, + { + let mut cache = CultCache::new(); + documents.register_cache(&mut cache)?; + cache + .add_generic_backing_store(SingleFileMessagePackBackingStore::new(store_path.as_ref())); + if options.pull_on_start { + cache.pull_all_backing_stores()?; + } + + let mut registry = CultNetDocumentRegistry::new(); + documents.register_documents(&mut registry)?; + + Ok(CultMeshNode { + runtime_id: options.runtime_id, + cache, + documents: registry, + }) + } + + pub fn start_node( + store_path: impl AsRef, + documents: D, + options: CultMeshNodeOptions, + ) -> Result + where + D: CultMeshDocumentSet, + { + Self::create_node(store_path, documents, options) + } + + pub fn create_stream_catalog() -> CultMeshStreamCatalog { + CultMeshStreamCatalog::default() + } +} + +pub fn create_node( + store_path: impl AsRef, + documents: D, + options: CultMeshNodeOptions, +) -> Result +where + D: CultMeshDocumentSet, +{ + CultMesh::create_node(store_path, documents, options) +} + +pub fn start_node( + store_path: impl AsRef, + documents: D, + options: CultMeshNodeOptions, +) -> Result +where + D: CultMeshDocumentSet, +{ + CultMesh::start_node(store_path, documents, options) +} + +pub fn create_stream_catalog() -> CultMeshStreamCatalog { + CultMesh::create_stream_catalog() +} + +pub fn resolve_rudp_endpoint(endpoint: &str) -> Result { + CultMesh::resolve_rudp_endpoint(endpoint) +} + +fn parse_rudp_socket_addr(value: &str) -> Result { + let text = value.trim().strip_prefix("rudp://").unwrap_or(value.trim()); + parse_socket_addr(text) +} + +fn parse_socket_addr(value: &str) -> Result { + value + .parse() + .with_context(|| format!("RUDP endpoint must be a socket address, got {value:?}")) +} + +fn default_cultmesh_rudp_endpoint_resolver(uri: &str) -> Result> { + let authority = cultmesh_uri_authority(uri)?; + let slug = authority + .chars() + .map(|ch| { + if ch.is_ascii_alphanumeric() { + ch.to_ascii_uppercase() + } else { + '_' + } + }) + .collect::() + .trim_matches('_') + .to_string(); + if slug.is_empty() { + return Ok(None); + } + + for key in [ + format!("CULTMESH_URI_{slug}_RUDP"), + format!("{slug}_CULTMESH_RUDP_ENDPOINT"), + ] { + if let Ok(value) = env::var(&key) { + let text = value.trim(); + if !text.is_empty() { + return Ok(Some(if text.starts_with("rudp://") { + text.to_string() + } else { + format!("rudp://{text}") + })); + } + } + } + Ok(None) +} + +fn cultmesh_uri_authority(uri: &str) -> Result { + let rest = uri + .strip_prefix("cultmesh://") + .ok_or_else(|| anyhow::anyhow!("CultMesh URI must start with cultmesh://"))?; + let authority = rest.split(['/', '?', '#']).next().unwrap_or("").trim(); + if authority.is_empty() { + anyhow::bail!("CultMesh URI must include an authority"); + } + Ok(authority.to_string()) +} + +#[cfg(test)] +mod tests { + use super::*; + use pretty_assertions::assert_eq; + + #[derive(Clone, Debug, PartialEq, Eq, cultcache_rs::DatabaseEntry)] + #[cultcache(type = "cultmesh.test.note", schema = "CultMeshTestNote")] + struct Note { + #[cultcache(key = 0)] + body: String, + } + + cultmesh_documents!(TestDocuments { + Note => "cultmesh.test.note.v0", + }); + + #[test] + fn node_round_trips_registered_documents() -> Result<()> { + let temp = tempfile::tempdir()?; + let store_path = temp.path().join("cultmesh.cc"); + let note = Note { + body: "blessed circuit".to_string(), + }; + + let mut node = CultMesh::create_node( + &store_path, + TestDocuments, + CultMeshNodeOptions { + runtime_id: "test-runtime".to_string(), + ..CultMeshNodeOptions::default() + }, + )?; + assert_eq!(node.runtime_id(), "test-runtime"); + node.put("note", ¬e)?; + node.flush()?; + + let reloaded = CultMesh::create_node(&store_path, TestDocuments, Default::default())?; + assert_eq!(reloaded.get_required::("note")?, note); + assert!( + reloaded + .documents() + .binding_by_schema_id("cultmesh.test.note.v0") + .is_some() + ); + Ok(()) + } + + #[test] + fn node_publishes_registered_document_to_rudp_catalog() -> Result<()> { + let temp = tempfile::tempdir()?; + let store_path = temp.path().join("cultmesh.cc"); + let note = Note { + body: "respect odin once".to_string(), + }; + let node = CultMesh::create_node( + &store_path, + TestDocuments, + CultMeshNodeOptions { + runtime_id: "muninn-test".to_string(), + ..CultMeshNodeOptions::default() + }, + )?; + + let socket = UdpSocket::bind("127.0.0.1:0")?; + socket.set_read_timeout(Some(Duration::from_millis(10)))?; + let target = socket.local_addr()?; + let (sender, receiver) = std::sync::mpsc::channel(); + let server = thread::spawn(move || -> Result<()> { + let mut server = CultNetRudpSocketTransportConnection::new( + CultNetRudpSocketTransportOptions::server( + "odin-test-catalog", + socket, + CULTMESH_RUDP_DOCUMENT_CATALOG_CONNECTION_ID, + ), + )?; + let deadline = Instant::now() + Duration::from_secs(2); + while Instant::now() < deadline { + if let Some(frame) = server.receive_once()? { + let message = cultnet_rs::decode_cultnet_message_from_slice( + &frame.payload, + CultNetWireContract::CultNetSchemaV0, + )?; + if let cultnet_rs::CultNetMessage::DocumentPutRaw { document, .. } = message { + sender + .send(( + document.schema_id, + document.record_key, + document.source_runtime_id, + )) + .ok(); + return Ok(()); + } + } + server.poll_resends()?; + } + anyhow::bail!("timed out waiting for RUDP document put") + }); + + node.publish_document_to_rudp_catalog( + "note", + ¬e, + CultMeshRudpDocumentPublishOptions::odin(target, "muninn-test"), + )?; + let received = receiver.recv_timeout(Duration::from_secs(2))?; + server.join().expect("server thread should not panic")?; + + assert_eq!(received.0, "cultmesh.test.note.v0"); + assert_eq!(received.1, "note"); + assert_eq!(received.2.as_deref(), Some("muninn-test")); + Ok(()) + } + + #[test] + fn resolves_rudp_endpoint_from_cultmesh_uri_bootstrap_env() -> Result<()> { + let previous = env::var("CULTMESH_URI_ODIN_RUDP").ok(); + unsafe { + env::set_var("CULTMESH_URI_ODIN_RUDP", "127.0.0.1:17871"); + } + let result = CultMesh::resolve_rudp_endpoint("cultmesh://odin/rendezvous/provider-catalog"); + unsafe { + if let Some(value) = previous { + env::set_var("CULTMESH_URI_ODIN_RUDP", value); + } else { + env::remove_var("CULTMESH_URI_ODIN_RUDP"); + } + } + + assert_eq!(result?, "127.0.0.1:17871".parse()?); + Ok(()) + } + + #[test] + fn rejects_unresolved_cultmesh_rudp_endpoint() { + let previous = env::var("CULTMESH_URI_MISSING_ODIN_RUDP").ok(); + unsafe { + env::remove_var("CULTMESH_URI_MISSING_ODIN_RUDP"); + } + let error = + CultMesh::resolve_rudp_endpoint("cultmesh://missing-odin/rendezvous/provider-catalog") + .expect_err("unresolved CultMesh URI should fail"); + unsafe { + if let Some(value) = previous { + env::set_var("CULTMESH_URI_MISSING_ODIN_RUDP", value); + } + } + assert!(error.to_string().contains("did not resolve")); + } + + #[test] + fn raw_snapshot_application_uses_registered_document_type() -> Result<()> { + let temp = tempfile::tempdir()?; + let store_path = temp.path().join("cultmesh.cc"); + let mut node = CultMesh::create_node( + &store_path, + TestDocuments, + CultMeshNodeOptions { + runtime_id: "snapshot-apply-test".to_string(), + ..CultMeshNodeOptions::default() + }, + )?; + let payload = rmp_serde::to_vec(&Note { + body: "catalog truth".to_string(), + })?; + + node.cache + .put_raw_envelope(cultcache_rs::CultCacheEnvelope { + key: "note".to_string(), + r#type: node + .documents + .binding_by_schema_id("cultmesh.test.note.v0") + .expect("test binding") + .document_type + .clone(), + payload, + stored_at: "2026-07-03T00:00:00Z".to_string(), + schema_id: Some("cultmesh.test.note.v0".to_string()), + })?; + node.flush()?; + + let reloaded = CultMesh::create_node(&store_path, TestDocuments, Default::default())?; + assert_eq!(reloaded.get_required::("note")?.body, "catalog truth"); + assert_eq!(reloaded.cache().snapshot()[0].r#type, Note::TYPE); + Ok(()) + } + + #[test] + fn stream_catalog_negotiates_and_publishes_latest_shared_memory_frame() -> Result<()> { + let mut catalog = CultMesh::create_stream_catalog(); + let stream = CultMeshStreamDescriptor::new( + "muninn:nightwing:move-evidence", + "mimir-live", + "muninn:nightwing", + CultMeshStreamKind::Bytes, + CultMeshStreamClock::new("muninn:nightwing:clock")? + .source_id("muninn:nightwing:move-evidence")? + .confidence(1.0) + .evidence_kind("muninn-move-evidence")?, + vec![ + CultMeshStreamBodyTransport::SharedMemory, + CultMeshStreamBodyTransport::CultCachePage, + ], + )? + .label("Muninn Move evidence")? + .max_in_flight_frames(4) + .metadata_schema_id("mimir.muninn_move_evidence_stream_frame.v1")?; + catalog.declare(stream); + + let consumer = CultMeshStreamConsumerProfile::new( + "mimir:starfire", + "mimir-live", + vec![CultMeshStreamBodyTransport::SharedMemory], + )?; + let negotiation = catalog.negotiate("muninn:nightwing:move-evidence", &consumer)?; + + assert_eq!( + negotiation.transport, + CultMeshStreamBodyTransport::SharedMemory + ); + assert_eq!( + negotiation.copy_budget, + CultMeshStreamCopyBudget::ZeroCopyTarget + ); + + let handle = { + let ring = + catalog.create_shared_memory_ring("muninn:nightwing:move-evidence", 4, 128)?; + ring.try_publish_copy(&[1, 2, 3], 42, 0)? + .expect("frame should publish") + }; + catalog.publish_frame(handle.clone())?; + + assert_eq!( + catalog.latest_frame("muninn:nightwing:move-evidence"), + Some(&handle) + ); + let lease = catalog + .ring("muninn:nightwing:move-evidence") + .and_then(CultMeshSharedMemoryFrameRing::try_acquire_latest_read) + .expect("latest frame should be readable"); + assert_eq!(lease.handle.sequence, 0); + assert_eq!(lease.bytes(), &[1, 2, 3]); + Ok(()) + } +} diff --git a/vendor/cultnet-rs/.gitignore b/vendor/cultnet-rs/.gitignore new file mode 100644 index 0000000..96ef6c0 --- /dev/null +++ b/vendor/cultnet-rs/.gitignore @@ -0,0 +1,2 @@ +/target +Cargo.lock diff --git a/vendor/cultnet-rs/Cargo.toml b/vendor/cultnet-rs/Cargo.toml new file mode 100644 index 0000000..41d14b5 --- /dev/null +++ b/vendor/cultnet-rs/Cargo.toml @@ -0,0 +1,32 @@ +[package] +name = "cultnet-rs" +version = "0.1.0" +edition = "2024" +publish = false +license = "MIT" +description = "CultNet-style typed MessagePack messaging, direct-pipe framing, security helpers, and CultCache replication for Rust runtimes." + +[lib] +name = "cultnet_rs" +path = "src/lib.rs" + +[dependencies] +aes-gcm = "0.10" +anyhow = "1" +base64 = "0.22" +chrono = { version = "0.4", features = ["serde"] } +cultcache-rs = { path = "../cultcache-rs" } +hmac = "0.12" +rand = "0.9" +rmp-serde = "1.3" +rmpv = { version = "1.3", features = ["with-serde"] } +serde = { version = "1", features = ["derive"] } +serde_bytes = "0.11" +serde_json = "1" +sha2 = "0.10" +socket2 = "0.5" +uuid = { version = "1", features = ["v4"] } + +[dev-dependencies] +pretty_assertions = "1.4" +tempfile = "3" diff --git a/vendor/cultnet-rs/README.md b/vendor/cultnet-rs/README.md new file mode 100644 index 0000000..8324a5b --- /dev/null +++ b/vendor/cultnet-rs/README.md @@ -0,0 +1,96 @@ +# CultNet RS + +`cultnet-rs` is the Rust sibling of `cultnet-ts`: typed MessagePack messages, +4-byte length-prefixed direct-pipe framing, stop-and-wait RUDP message delivery, +CultLib-shaped security helpers, and CultCache replication without making +callers paw through raw envelopes like we lost a bet. + +The contract is intentionally boring: + +- `cultnet.schema.v0` sends schema-versioned MessagePack objects. +- `gamecult.networking.v0` maps the legacy C# union shape explicitly. +- schema discovery uses explicit catalog request/response messages; no inbound + auto-detect sludge. +- document put/delete/snapshot messages move typed CultCache entries. +- raw document put/snapshot messages preserve canonical MessagePack payload + bytes for bit-compatible neighbors. +- `cultnet.transport.rudp.v0` carries one CultNet message per acknowledged UDP + datagram with timeout/retry semantics. +- hello messages advertise `supportedMutationContracts`, so callers discover + which document types are read-only, which accept typed intents, which + authority owns the mutation, and which receipt documents prove the outcome. +- payloads are decoded through registered Rust types before entering the cache. + +This crate is not an HTTP wrapper. It is the wire vocabulary Epiphany, +Ghostlight, VoidBot, and the rest of the swarm can share. + +The public API surface is the schema plus its mutation contracts. A runtime does +not expose a pile of bespoke verbs and hope everyone remembers the ritual; it +advertises typed documents, typed intents, and typed receipts. Polite machines +knock on the contract before touching the furniture. + +## Receipts + +```powershell +cargo test +``` + +The initial tests prove: + +- CultLib-compatible AES-GCM string encryption and HMAC session tokens +- 4-byte big-endian MessagePack framing +- schema-versioned message round trips +- legacy `gamecult.networking.v0` login mapping +- schema discovery catalog responses with canonical JSON schema hashes +- CultCache snapshot replication through registered typed documents +- raw snapshot replication that preserves the original payload bytes +- document mutation contract advertisement through hello frames and registries +- acknowledged localhost UDP delivery through `cultnet.transport.rudp.v0` + +## RUDP Transport + +`cultnet.transport.rudp.v0` is the Rust crate's first non-TCP daemon transport. +It is intentionally small: one CultNet message becomes one UDP data packet, the +receiver sends an acknowledgement packet, and the sender retries until the ack +arrives or the retry budget is spent. + +This is a daemon health/control substrate, not a bulk stream transport. It does +not fragment oversized messages, multiplex streams, or promise congestion +control. Large snapshots should stay in CultCache/CultMesh storage and move by +document reference or a later chunking contract. The useful invariant is simple: +Rust runtimes can now move a typed CultNet message across UDP without reaching +for TCP as the hidden truth path. + +## Schema Discovery + +`cultnet-rs` now ships a built-in schema registry for the shared swarm contract +surface: + +- core wire messages +- legacy `gamecult.networking.v0` auth/sample payloads +- schema catalog request/response messages +- the canonical `ghostlight.agent-state` document payload schema + +Use `builtin_schema_registry()` when you want the standard catalog, or register +your own closed-world schema set with `CultNetSchemaRegistry`. Discovery stays +explicit on purpose: peers advertise only the contracts they were compiled to +understand, the same way CultCache only consumes the document types you +registered instead of pretending polymorphism is a public park. + +## Local Fast Lane + +`cultnet-rs` now mirrors the raw replication seam from `cultnet-ts`: + +- `cultnet.document_put_raw.v0` +- `cultnet.snapshot_response_raw.v0` + +Those messages carry the exact persisted MessagePack payload bytes from +CultCache along with the typed envelope metadata. Combined with +`CultCache::put_envelope::()`, that lets a bit-compatible neighbor ingest the +document without re-encoding the payload first. + +That still is not zero-copy in the religious sense. Frames allocate, bytes move, +and the receiving cache still decodes once to keep typed reads and validation +honest. The win is narrower and realer: identical payload bytes stop getting +decoded into generic sludge and then encoded right back into the same bytes for +no reason. diff --git a/vendor/cultnet-rs/contracts/cultnet.document-delete.schema.json b/vendor/cultnet-rs/contracts/cultnet.document-delete.schema.json new file mode 100644 index 0000000..265bcaf --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.document-delete.schema.json @@ -0,0 +1,19 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.document-delete.schema.json", + "title": "CultNet Document Delete Message", + "type": "object", + "required": [ + "schemaVersion", + "messageId", + "schemaId", + "recordKey" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.document_delete.v0" }, + "messageId": { "type": "string", "minLength": 1 }, + "schemaId": { "type": "string", "minLength": 1 }, + "recordKey": { "type": "string", "minLength": 1 } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.document-mutation-contract.schema.json b/vendor/cultnet-rs/contracts/cultnet.document-mutation-contract.schema.json new file mode 100644 index 0000000..e444fef --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.document-mutation-contract.schema.json @@ -0,0 +1,40 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.document-mutation-contract.schema.json", + "title": "CultNet Document Mutation Contract", + "type": "object", + "required": [ + "documentType", + "operations", + "authority" + ], + "additionalProperties": false, + "properties": { + "documentType": { "type": "string", "minLength": 1 }, + "payloadSchemaVersion": { "type": "string", "minLength": 1 }, + "operations": { + "type": "array", + "minItems": 1, + "items": { + "type": "string", + "enum": ["snapshot", "documentPut", "documentDelete", "intentSubmit", "receiptWatch"] + } + }, + "authority": { + "type": "string", + "enum": ["readOnly", "localUser", "coordinator", "runtime", "denied"] + }, + "intentDocumentTypes": { + "type": "array", + "items": { "type": "string", "minLength": 1 } + }, + "receiptDocumentTypes": { + "type": "array", + "items": { "type": "string", "minLength": 1 } + }, + "notes": { + "type": "array", + "items": { "type": "string", "minLength": 1 } + } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.document-put-raw.schema.json b/vendor/cultnet-rs/contracts/cultnet.document-put-raw.schema.json new file mode 100644 index 0000000..3c178d0 --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.document-put-raw.schema.json @@ -0,0 +1,19 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.document-put-raw.schema.json", + "title": "CultNet Raw Document Put Message", + "type": "object", + "required": [ + "schemaVersion", + "messageId", + "document" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.document_put_raw.v0" }, + "messageId": { "type": "string", "minLength": 1 }, + "document": { + "$ref": "./cultnet.raw-document-record.schema.json" + } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.document-put.schema.json b/vendor/cultnet-rs/contracts/cultnet.document-put.schema.json new file mode 100644 index 0000000..a04f5fc --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.document-put.schema.json @@ -0,0 +1,19 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.document-put.schema.json", + "title": "CultNet Document Put Message", + "type": "object", + "required": [ + "schemaVersion", + "messageId", + "document" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.document_put.v0" }, + "messageId": { "type": "string", "minLength": 1 }, + "document": { + "$ref": "./cultnet.document-record.schema.json" + } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.document-record.schema.json b/vendor/cultnet-rs/contracts/cultnet.document-record.schema.json new file mode 100644 index 0000000..94301dc --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.document-record.schema.json @@ -0,0 +1,26 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.document-record.schema.json", + "title": "CultNet Document Record", + "type": "object", + "required": [ + "schemaId", + "recordKey", + "storedAt", + "payload" + ], + "additionalProperties": false, + "properties": { + "schemaId": { "type": "string", "minLength": 1 }, + "recordKey": { "type": "string", "minLength": 1 }, + "storedAt": { "type": "string", "minLength": 1 }, + "payload": {}, + "sourceRuntimeId": { "type": "string", "minLength": 1 }, + "sourceAgentId": { "type": "string", "minLength": 1 }, + "sourceRole": { "type": "string", "minLength": 1 }, + "tags": { + "type": "array", + "items": { "type": "string", "minLength": 1 } + } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.error.schema.json b/vendor/cultnet-rs/contracts/cultnet.error.schema.json new file mode 100644 index 0000000..af6da9c --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.error.schema.json @@ -0,0 +1,15 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.error.schema.json", + "title": "CultNet Error Message", + "type": "object", + "required": [ + "schemaVersion", + "error" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.error.v0" }, + "error": { "type": "string", "minLength": 1 } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.hello.schema.json b/vendor/cultnet-rs/contracts/cultnet.hello.schema.json new file mode 100644 index 0000000..a557dc3 --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.hello.schema.json @@ -0,0 +1,41 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.hello.schema.json", + "title": "CultNet Hello Message", + "type": "object", + "required": [ + "schemaVersion", + "runtimeId", + "runtimeKind" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.hello.v0" }, + "runtimeId": { "type": "string", "minLength": 1 }, + "runtimeKind": { "type": "string", "minLength": 1 }, + "agentId": { "type": "string", "minLength": 1 }, + "role": { "type": "string", "minLength": 1 }, + "displayName": { "type": "string", "minLength": 1 }, + "supportedDocumentTypes": { + "type": "array", + "items": { "type": "string", "minLength": 1 } + }, + "supportedMutationContracts": { + "type": "array", + "items": { + "$ref": "./cultnet.document-mutation-contract.schema.json" + } + }, + "supportedMessageVersions": { + "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.login-success.schema.json b/vendor/cultnet-rs/contracts/cultnet.login-success.schema.json new file mode 100644 index 0000000..3d8a459 --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.login-success.schema.json @@ -0,0 +1,17 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.login-success.schema.json", + "title": "CultNet Login Success Message", + "type": "object", + "required": [ + "schemaVersion", + "nonce", + "session" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.login_success.v0" }, + "nonce": { "type": "string", "minLength": 1 }, + "session": { "type": "string", "minLength": 1 } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.login.schema.json b/vendor/cultnet-rs/contracts/cultnet.login.schema.json new file mode 100644 index 0000000..62f4959 --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.login.schema.json @@ -0,0 +1,19 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.login.schema.json", + "title": "CultNet Login Message", + "type": "object", + "required": [ + "schemaVersion", + "nonce", + "auth", + "password" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.login.v0" }, + "nonce": { "type": "string", "minLength": 1 }, + "auth": { "type": "string", "minLength": 1 }, + "password": { "type": "string", "minLength": 1 } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.raw-document-record.schema.json b/vendor/cultnet-rs/contracts/cultnet.raw-document-record.schema.json new file mode 100644 index 0000000..3348a5f --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.raw-document-record.schema.json @@ -0,0 +1,32 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.raw-document-record.schema.json", + "title": "CultNet Raw Document Record", + "type": "object", + "required": [ + "schemaId", + "recordKey", + "storedAt", + "payloadEncoding", + "payload" + ], + "additionalProperties": false, + "properties": { + "schemaId": { "type": "string", "minLength": 1 }, + "recordKey": { "type": "string", "minLength": 1 }, + "storedAt": { "type": "string", "minLength": 1 }, + "payloadEncoding": { "const": "messagepack" }, + "payload": { + "type": "string", + "contentEncoding": "base64", + "x-cult-runtime-type": "bytes" + }, + "sourceRuntimeId": { "type": "string", "minLength": 1 }, + "sourceAgentId": { "type": "string", "minLength": 1 }, + "sourceRole": { "type": "string", "minLength": 1 }, + "tags": { + "type": "array", + "items": { "type": "string", "minLength": 1 } + } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.register.schema.json b/vendor/cultnet-rs/contracts/cultnet.register.schema.json new file mode 100644 index 0000000..77286f3 --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.register.schema.json @@ -0,0 +1,21 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.register.schema.json", + "title": "CultNet Register Message", + "type": "object", + "required": [ + "schemaVersion", + "nonce", + "email", + "password", + "name" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.register.v0" }, + "nonce": { "type": "string", "minLength": 1 }, + "email": { "type": "string", "minLength": 1 }, + "password": { "type": "string", "minLength": 1 }, + "name": { "type": "string", "minLength": 1 } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.sample-change-name.schema.json b/vendor/cultnet-rs/contracts/cultnet.sample-change-name.schema.json new file mode 100644 index 0000000..fc3fe05 --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.sample-change-name.schema.json @@ -0,0 +1,15 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.sample-change-name.schema.json", + "title": "CultNet Sample Change Name Message", + "type": "object", + "required": [ + "schemaVersion", + "name" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.sample.change_name.v0" }, + "name": { "type": "string", "minLength": 1 } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.sample-chat.schema.json b/vendor/cultnet-rs/contracts/cultnet.sample-chat.schema.json new file mode 100644 index 0000000..8426fb5 --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.sample-chat.schema.json @@ -0,0 +1,15 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.sample-chat.schema.json", + "title": "CultNet Sample Chat Message", + "type": "object", + "required": [ + "schemaVersion", + "text" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.sample.chat.v0" }, + "text": { "type": "string", "minLength": 1 } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.schema-catalog-request.schema.json b/vendor/cultnet-rs/contracts/cultnet.schema-catalog-request.schema.json new file mode 100644 index 0000000..611733d --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.schema-catalog-request.schema.json @@ -0,0 +1,31 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.schema-catalog-request.schema.json", + "title": "CultNet Schema Catalog Request Message", + "type": "object", + "required": [ + "schemaVersion", + "messageId" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.schema_catalog_request.v0" }, + "messageId": { "type": "string", "minLength": 1 }, + "includeSchemaJson": { "type": "boolean" }, + "schemaIds": { + "type": "array", + "items": { "type": "string", "minLength": 1 } + }, + "kinds": { + "type": "array", + "items": { + "type": "string", + "enum": [ + "wire_message", + "document_payload", + "shared_contract" + ] + } + } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.schema-catalog-response.schema.json b/vendor/cultnet-rs/contracts/cultnet.schema-catalog-response.schema.json new file mode 100644 index 0000000..fa371e4 --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.schema-catalog-response.schema.json @@ -0,0 +1,22 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.schema-catalog-response.schema.json", + "title": "CultNet Schema Catalog Response Message", + "type": "object", + "required": [ + "schemaVersion", + "messageId", + "schemas" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.schema_catalog_response.v0" }, + "messageId": { "type": "string", "minLength": 1 }, + "schemas": { + "type": "array", + "items": { + "$ref": "./cultnet.schema-descriptor.schema.json" + } + } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.schema-descriptor.schema.json b/vendor/cultnet-rs/contracts/cultnet.schema-descriptor.schema.json new file mode 100644 index 0000000..2379685 --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.schema-descriptor.schema.json @@ -0,0 +1,39 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.schema-descriptor.schema.json", + "title": "CultNet Schema Descriptor", + "type": "object", + "required": [ + "schemaId", + "kind", + "wireContracts", + "contentHash" + ], + "additionalProperties": false, + "properties": { + "schemaId": { "type": "string", "minLength": 1 }, + "kind": { + "type": "string", + "enum": [ + "wire_message", + "document_payload", + "shared_contract" + ] + }, + "schemaVersion": { "type": "string", "minLength": 1 }, + "documentType": { "type": "string", "minLength": 1 }, + "title": { "type": "string", "minLength": 1 }, + "wireContracts": { + "type": "array", + "items": { + "type": "string", + "enum": [ + "cultnet.schema.v0", + "gamecult.networking.v0" + ] + } + }, + "contentHash": { "type": "string", "minLength": 1 }, + "schemaJson": { "type": "string", "minLength": 1 } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.snapshot-request.schema.json b/vendor/cultnet-rs/contracts/cultnet.snapshot-request.schema.json new file mode 100644 index 0000000..712d705 --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.snapshot-request.schema.json @@ -0,0 +1,23 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.snapshot-request.schema.json", + "title": "CultNet Snapshot Request Message", + "type": "object", + "required": [ + "schemaVersion", + "messageId" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.snapshot_request.v0" }, + "messageId": { "type": "string", "minLength": 1 }, + "schemaIds": { + "type": "array", + "items": { "type": "string", "minLength": 1 } + }, + "recordKeys": { + "type": "array", + "items": { "type": "string", "minLength": 1 } + } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.snapshot-response-raw.schema.json b/vendor/cultnet-rs/contracts/cultnet.snapshot-response-raw.schema.json new file mode 100644 index 0000000..a84bc50 --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.snapshot-response-raw.schema.json @@ -0,0 +1,22 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.snapshot-response-raw.schema.json", + "title": "CultNet Raw Snapshot Response Message", + "type": "object", + "required": [ + "schemaVersion", + "messageId", + "documents" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.snapshot_response_raw.v0" }, + "messageId": { "type": "string", "minLength": 1 }, + "documents": { + "type": "array", + "items": { + "$ref": "./cultnet.raw-document-record.schema.json" + } + } + } +} diff --git a/vendor/cultnet-rs/contracts/cultnet.snapshot-response.schema.json b/vendor/cultnet-rs/contracts/cultnet.snapshot-response.schema.json new file mode 100644 index 0000000..940822c --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.snapshot-response.schema.json @@ -0,0 +1,22 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.snapshot-response.schema.json", + "title": "CultNet Snapshot Response Message", + "type": "object", + "required": [ + "schemaVersion", + "messageId", + "documents" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.snapshot_response.v0" }, + "messageId": { "type": "string", "minLength": 1 }, + "documents": { + "type": "array", + "items": { + "$ref": "./cultnet.document-record.schema.json" + } + } + } +} 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/contracts/cultnet.verify.schema.json b/vendor/cultnet-rs/contracts/cultnet.verify.schema.json new file mode 100644 index 0000000..1f992aa --- /dev/null +++ b/vendor/cultnet-rs/contracts/cultnet.verify.schema.json @@ -0,0 +1,17 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/cultnet-ts/contracts/cultnet.verify.schema.json", + "title": "CultNet Verify Message", + "type": "object", + "required": [ + "schemaVersion", + "nonce", + "session" + ], + "additionalProperties": false, + "properties": { + "schemaVersion": { "const": "cultnet.verify.v0" }, + "nonce": { "type": "string", "minLength": 1 }, + "session": { "type": "string", "minLength": 1 } + } +} diff --git a/vendor/cultnet-rs/contracts/ghostlight.agent-state.schema.json b/vendor/cultnet-rs/contracts/ghostlight.agent-state.schema.json new file mode 100644 index 0000000..6437cd0 --- /dev/null +++ b/vendor/cultnet-rs/contracts/ghostlight.agent-state.schema.json @@ -0,0 +1,845 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://github.com/GameCult/Ghostlight/schemas/agent-state.schema.json", + "title": "Ghostlight Agent State Schema", + "description": "First canonical contract for Ghostlight agent, perception, relationship, event, scene, and dialogue-context state.", + "type": "object", + "required": [ + "schema_version", + "world", + "agents", + "relationships", + "events", + "scenes" + ], + "additionalProperties": false, + "properties": { + "schema_version": { + "const": "ghostlight.agent_state.v0" + }, + "world": { + "$ref": "#/$defs/world_state" + }, + "agents": { + "type": "array", + "items": { + "$ref": "#/$defs/agent" + } + }, + "relationships": { + "type": "array", + "items": { + "$ref": "#/$defs/relationship" + } + }, + "events": { + "type": "array", + "items": { + "$ref": "#/$defs/event" + } + }, + "scenes": { + "type": "array", + "items": { + "$ref": "#/$defs/scene" + } + } + }, + "$defs": { + "world_state": { + "type": "object", + "required": [ + "world_id", + "setting", + "time", + "canon_context" + ], + "additionalProperties": false, + "properties": { + "world_id": { + "type": "string" + }, + "setting": { + "type": "string" + }, + "time": { + "type": "object", + "required": [ + "label" + ], + "additionalProperties": true, + "properties": { + "label": { + "type": "string" + } + } + }, + "canon_context": { + "type": "array", + "items": { + "type": "string" + } + }, + "ambient_pressures": { + "type": "array", + "items": { + "$ref": "#/$defs/pressure" + } + } + } + }, + "agent": { + "type": "object", + "required": [ + "agent_id", + "identity", + "canonical_state", + "goals", + "memories", + "perceived_state_overlays" + ], + "additionalProperties": false, + "properties": { + "agent_id": { + "type": "string" + }, + "identity": { + "$ref": "#/$defs/identity" + }, + "canonical_state": { + "$ref": "#/$defs/canonical_state" + }, + "goals": { + "type": "array", + "items": { + "$ref": "#/$defs/goal" + } + }, + "memories": { + "$ref": "#/$defs/memory_bundle" + }, + "perceived_state_overlays": { + "type": "array", + "items": { + "$ref": "#/$defs/perceived_state_overlay" + } + } + } + }, + "identity": { + "type": "object", + "required": [ + "name", + "roles", + "origin", + "public_description" + ], + "additionalProperties": false, + "properties": { + "name": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + } + }, + "origin": { + "type": "string" + }, + "public_description": { + "type": "string" + }, + "private_notes": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "canonical_state": { + "type": "object", + "required": [ + "underlying_organization", + "stable_dispositions", + "behavioral_dimensions", + "presentation_strategy", + "voice_style", + "situational_state", + "values" + ], + "additionalProperties": false, + "properties": { + "underlying_organization": { + "$ref": "#/$defs/variable_map" + }, + "stable_dispositions": { + "$ref": "#/$defs/variable_map" + }, + "behavioral_dimensions": { + "$ref": "#/$defs/variable_map" + }, + "presentation_strategy": { + "$ref": "#/$defs/variable_map" + }, + "situational_state": { + "$ref": "#/$defs/variable_map" + }, + "values": { + "type": "array", + "items": { + "$ref": "#/$defs/value_commitment" + } + }, + "voice_style": { + "$ref": "#/$defs/variable_map" + } + } + }, + "variable_map": { + "type": "object", + "additionalProperties": { + "$ref": "#/$defs/state_variable" + } + }, + "state_variable": { + "type": "object", + "required": [ + "mean", + "plasticity", + "current_activation" + ], + "additionalProperties": false, + "properties": { + "mean": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "plasticity": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "current_activation": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "evidence": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "value_commitment": { + "type": "object", + "required": [ + "value_id", + "label", + "priority", + "unforgivable_if_betrayed" + ], + "additionalProperties": false, + "properties": { + "value_id": { + "type": "string" + }, + "label": { + "type": "string" + }, + "priority": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "unforgivable_if_betrayed": { + "type": "boolean" + } + } + }, + "goal": { + "type": "object", + "required": [ + "goal_id", + "description", + "scope", + "priority", + "emotional_stake", + "status" + ], + "additionalProperties": false, + "properties": { + "goal_id": { + "type": "string" + }, + "description": { + "type": "string" + }, + "scope": { + "enum": [ + "immediate", + "scene", + "case", + "arc", + "life" + ] + }, + "priority": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "emotional_stake": { + "type": "string" + }, + "blockers": { + "type": "array", + "items": { + "type": "string" + } + }, + "status": { + "enum": [ + "active", + "blocked", + "dormant", + "resolved", + "abandoned" + ] + } + } + }, + "memory_bundle": { + "type": "object", + "required": [ + "episodic", + "semantic", + "relationship_summaries" + ], + "additionalProperties": false, + "properties": { + "episodic": { + "type": "array", + "items": { + "$ref": "#/$defs/memory" + } + }, + "semantic": { + "type": "array", + "items": { + "$ref": "#/$defs/memory" + } + }, + "relationship_summaries": { + "type": "array", + "items": { + "$ref": "#/$defs/memory" + } + } + } + }, + "memory": { + "type": "object", + "required": [ + "memory_id", + "summary", + "salience", + "confidence" + ], + "additionalProperties": false, + "properties": { + "memory_id": { + "type": "string" + }, + "summary": { + "type": "string" + }, + "salience": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "confidence": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "linked_event_ids": { + "type": "array", + "items": { + "type": "string" + } + }, + "linked_relationship_id": { + "type": "string" + } + } + }, + "perceived_state_overlay": { + "type": "object", + "required": [ + "observer_agent_id", + "target_agent_id", + "perceived_dimensions", + "beliefs", + "distortions" + ], + "additionalProperties": false, + "properties": { + "observer_agent_id": { + "type": "string" + }, + "target_agent_id": { + "type": "string" + }, + "perceived_dimensions": { + "$ref": "#/$defs/inferred_variable_map" + }, + "beliefs": { + "type": "array", + "items": { + "$ref": "#/$defs/belief" + } + }, + "distortions": { + "type": "array", + "items": { + "enum": [ + "hostile_attribution", + "false_reassurance", + "overread_warmth", + "underread_threat", + "false_mask_detection", + "missed_mask_detection", + "status_injury", + "threat_amplification", + "institutional_suspicion_transfer", + "care_underread", + "mask_overfocus" + ] + } + } + } + }, + "belief": { + "type": "object", + "required": [ + "belief_id", + "claim", + "confidence" + ], + "additionalProperties": false, + "properties": { + "belief_id": { + "type": "string" + }, + "claim": { + "type": "string" + }, + "confidence": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "subject_id": { + "type": "string" + }, + "claim_type": { + "enum": [ + "fact", + "identity_inference", + "motive_inference", + "prediction", + "norm", + "value_read", + "relationship_read" + ] + }, + "evidence_event_ids": { + "type": "array", + "items": { + "type": "string" + } + }, + "visibility": { + "enum": [ + "private", + "shared", + "public", + "rumor" + ] + }, + "emotional_charge": { + "type": "number", + "minimum": 0, + "maximum": 1 + } + } + }, + "relationship": { + "type": "object", + "required": [ + "relationship_id", + "source_id", + "target_id", + "stance", + "summary" + ], + "additionalProperties": false, + "properties": { + "relationship_id": { + "type": "string" + }, + "source_id": { + "type": "string" + }, + "target_id": { + "type": "string" + }, + "stance": { + "$ref": "#/$defs/variable_map" + }, + "summary": { + "type": "string" + }, + "unresolved_incident_ids": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "event": { + "type": "object", + "required": [ + "event_id", + "kind", + "summary", + "participants", + "pressure_tags" + ], + "additionalProperties": false, + "properties": { + "event_id": { + "type": "string" + }, + "kind": { + "enum": [ + "dialogue", + "action", + "memory", + "relationship_shift", + "scene_outcome", + "author_note" + ] + }, + "summary": { + "type": "string" + }, + "participants": { + "type": "array", + "items": { + "type": "string" + } + }, + "pressure_tags": { + "type": "array", + "items": { + "type": "string" + } + }, + "observed_exchange": { + "type": "array", + "items": { + "$ref": "#/$defs/event_exchange_turn" + } + }, + "private_interpretations": { + "type": "array", + "items": { + "$ref": "#/$defs/event_private_interpretation" + } + }, + "event_effects": { + "type": "array", + "items": { + "$ref": "#/$defs/event_effect" + } + } + } + }, + "scene": { + "type": "object", + "required": [ + "scene_id", + "location", + "participants", + "public_stakes", + "hidden_stakes", + "dialogue_context_packs" + ], + "additionalProperties": false, + "properties": { + "scene_id": { + "type": "string" + }, + "location": { + "type": "string" + }, + "participants": { + "type": "array", + "items": { + "type": "string" + } + }, + "public_stakes": { + "type": "array", + "items": { + "type": "string" + } + }, + "hidden_stakes": { + "type": "array", + "items": { + "type": "string" + } + }, + "dialogue_context_packs": { + "type": "array", + "items": { + "$ref": "#/$defs/dialogue_context_pack" + } + } + } + }, + "dialogue_context_pack": { + "type": "object", + "required": [ + "speaker_agent_id", + "listener_ids", + "speaker_local_truth", + "speaker_beliefs", + "active_memories", + "active_goals", + "presentation_constraints" + ], + "additionalProperties": false, + "properties": { + "speaker_agent_id": { + "type": "string" + }, + "listener_ids": { + "type": "array", + "items": { + "type": "string" + } + }, + "speaker_local_truth": { + "type": "array", + "items": { + "type": "string" + } + }, + "speaker_beliefs": { + "type": "array", + "items": { + "type": "string" + } + }, + "active_memories": { + "type": "array", + "items": { + "type": "string" + } + }, + "active_goals": { + "type": "array", + "items": { + "type": "string" + } + }, + "presentation_constraints": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "pressure": { + "type": "object", + "required": [ + "pressure_id", + "label", + "intensity" + ], + "additionalProperties": false, + "properties": { + "pressure_id": { + "type": "string" + }, + "label": { + "type": "string" + }, + "intensity": { + "type": "number", + "minimum": 0, + "maximum": 1 + } + } + }, + "inferred_variable_map": { + "type": "object", + "additionalProperties": { + "$ref": "#/$defs/inferred_state_variable" + } + }, + "inferred_state_variable": { + "type": "object", + "required": [ + "observed_activation", + "attributed_disposition", + "confidence" + ], + "additionalProperties": false, + "properties": { + "observed_activation": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "attributed_disposition": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "confidence": { + "type": "number", + "minimum": 0, + "maximum": 1 + }, + "evidence": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "event_exchange_turn": { + "type": "object", + "required": [ + "speaker_id", + "utterance_summary", + "dialogue_function" + ], + "additionalProperties": false, + "properties": { + "speaker_id": { + "type": "string" + }, + "utterance_summary": { + "type": "string" + }, + "dialogue_function": { + "type": "string" + }, + "observable_cues": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "event_private_interpretation": { + "type": "object", + "required": [ + "agent_id", + "interpretation", + "confidence" + ], + "additionalProperties": false, + "properties": { + "agent_id": { + "type": "string" + }, + "interpretation": { + "type": "string" + }, + "attributed_motive": { + "type": "string" + }, + "appraisal_tags": { + "type": "array", + "items": { + "type": "string" + } + }, + "confidence": { + "type": "number", + "minimum": 0, + "maximum": 1 + } + } + }, + "event_effect": { + "type": "object", + "required": [ + "agent_id", + "summary" + ], + "additionalProperties": false, + "properties": { + "agent_id": { + "type": "string" + }, + "summary": { + "type": "string" + }, + "state_deltas": { + "type": "array", + "items": { + "$ref": "#/$defs/state_delta" + } + }, + "new_belief_ids": { + "type": "array", + "items": { + "type": "string" + } + }, + "memory_update_ids": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "state_delta": { + "type": "object", + "required": [ + "path", + "delta" + ], + "additionalProperties": false, + "properties": { + "path": { + "type": "string" + }, + "delta": { + "type": "number", + "minimum": -1, + "maximum": 1 + } + } + } + } +} diff --git a/vendor/cultnet-rs/examples/cultnet_interop_peer.rs b/vendor/cultnet-rs/examples/cultnet_interop_peer.rs new file mode 100644 index 0000000..0a00c63 --- /dev/null +++ b/vendor/cultnet-rs/examples/cultnet_interop_peer.rs @@ -0,0 +1,1026 @@ +use anyhow::Context; +use anyhow::Result; +use anyhow::anyhow; +use cultcache_rs::CultCache; +use cultcache_rs::DatabaseEntry; +use cultcache_rs::SingleFileMessagePackBackingStore; +use cultnet_rs::CultNetDocumentBinding; +use cultnet_rs::CultNetDocumentMutationContract; +use cultnet_rs::CultNetDocumentOperation; +use cultnet_rs::CultNetDocumentPutOptions; +use cultnet_rs::CultNetDocumentRegistry; +use cultnet_rs::CultNetMessage; +use cultnet_rs::CultNetMutationAuthority; +use cultnet_rs::CultNetSchemaKind; +use cultnet_rs::CultNetSchemaRegistration; +use cultnet_rs::CultNetSchemaRegistry; +use cultnet_rs::CultNetTransportChannel; +use cultnet_rs::CultNetTransportDelivery; +use cultnet_rs::CultNetTransportDescriptor; +use cultnet_rs::CultNetTransportOrdering; +use cultnet_rs::CultNetTransportProfile; +use cultnet_rs::CultNetTransportProtocol; +use cultnet_rs::CultNetWireContract; +use cultnet_rs::builtin_schema_registry; +use cultnet_rs::decode_cultnet_message_from_slice; +use cultnet_rs::encode_cultnet_message_to_vec; +use cultnet_rs::encode_frame; +use serde::Deserialize; +use serde::Serialize; +use socket2::Domain; +use socket2::Protocol; +use socket2::Socket; +use socket2::Type; +use std::collections::BTreeMap; +use std::fs; +use std::io::Read; +use std::io::Write; +use std::net::Ipv4Addr; +use std::net::SocketAddr; +use std::net::SocketAddrV4; +use std::net::TcpListener; +use std::net::TcpStream; +use std::net::UdpSocket; +use std::sync::Arc; +use std::sync::Mutex; +use std::thread; +use std::time::Duration; + +const INTEROP_DOCUMENT_TYPE: &str = "cultnet.interop-note"; +const INTEROP_SCHEMA_VERSION: &str = "cultnet.interop_note.v0"; +const MUTATION_INTENT_TYPE: &str = "cultnet.interop-note-mutation-intent"; +const MUTATION_INTENT_SCHEMA_ID: &str = "https://github.com/GameCult/cultnet-ts/integration/contracts/cultnet.interop-note-mutation-intent.schema.json"; +const MUTATION_INTENT_SCHEMA_VERSION: &str = "cultnet.interop_note_mutation_intent.v0"; +const MUTATION_RECEIPT_TYPE: &str = "cultnet.interop-note-mutation-receipt"; +const MUTATION_RECEIPT_SCHEMA_ID: &str = "https://github.com/GameCult/cultnet-ts/integration/contracts/cultnet.interop-note-mutation-receipt.schema.json"; +const MUTATION_RECEIPT_SCHEMA_VERSION: &str = "cultnet.interop_note_mutation_receipt.v0"; +const FIRE_COMMAND_TYPE: &str = "cultnet.interop-fire-weapon-command"; +const FIRE_COMMAND_SCHEMA_ID: &str = "https://github.com/GameCult/cultnet-ts/integration/contracts/cultnet.interop-fire-weapon-command.schema.json"; +const FIRE_COMMAND_SCHEMA_VERSION: &str = "cultnet.interop_fire_weapon_command.v0"; +const FIRE_RECEIPT_TYPE: &str = "cultnet.interop-fire-weapon-receipt"; +const FIRE_RECEIPT_SCHEMA_ID: &str = "https://github.com/GameCult/cultnet-ts/integration/contracts/cultnet.interop-fire-weapon-receipt.schema.json"; +const FIRE_RECEIPT_SCHEMA_VERSION: &str = "cultnet.interop_fire_weapon_receipt.v0"; +const DISCOVERY_ANNOUNCE_SCHEMA_VERSION: &str = "cultnet.discovery_announce.v0"; + +#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] +#[cultcache(type = "cultnet.interop-note", schema = "CultNetInteropNote")] +struct CultNetInteropNote { + #[cultcache(key = 0)] + schema_version: String, + #[cultcache(key = 1)] + document_id: String, + #[cultcache(key = 2)] + author_runtime_id: String, + #[cultcache(key = 3)] + title: String, + #[cultcache(key = 4)] + body: String, + #[cultcache(key = 5)] + tags: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] +#[cultcache( + type = "cultnet.interop-note-mutation-intent", + schema = "CultNetInteropMutationIntent" +)] +struct CultNetInteropMutationIntent { + #[cultcache(key = 0)] + schema_version: String, + #[cultcache(key = 1)] + intent_id: String, + #[cultcache(key = 2)] + target_document_id: String, + #[cultcache(key = 3)] + append_body: String, + #[cultcache(key = 4)] + append_tag: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] +#[cultcache( + type = "cultnet.interop-note-mutation-receipt", + schema = "CultNetInteropMutationReceipt" +)] +struct CultNetInteropMutationReceipt { + #[cultcache(key = 0)] + schema_version: String, + #[cultcache(key = 1)] + intent_id: String, + #[cultcache(key = 2)] + accepted: bool, + #[cultcache(key = 3)] + document_id: String, + #[cultcache(key = 4)] + body: String, + #[cultcache(key = 5)] + tags: Vec, +} + +#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] +#[cultcache( + type = "cultnet.interop-fire-weapon-command", + schema = "CultNetInteropFireCommand" +)] +struct CultNetInteropFireCommand { + #[cultcache(key = 0)] + schema_version: String, + #[cultcache(key = 1)] + command_id: String, + #[cultcache(key = 2)] + character_id: String, + #[cultcache(key = 3)] + weapon_id: String, +} + +#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)] +#[cultcache( + type = "cultnet.interop-fire-weapon-receipt", + schema = "CultNetInteropFireReceipt" +)] +struct CultNetInteropFireReceipt { + #[cultcache(key = 0)] + schema_version: String, + #[cultcache(key = 1)] + command_id: String, + #[cultcache(key = 2)] + accepted: bool, + #[cultcache(key = 3)] + character_id: String, + #[cultcache(key = 4)] + weapon_id: String, + #[cultcache(key = 5)] + shots_fired: u32, + #[cultcache(key = 6)] + ammo_remaining: u32, +} + +#[derive(Clone, Debug, Serialize, Deserialize)] +#[serde(tag = "schemaVersion", rename_all = "camelCase")] +enum DiscoveryMessage { + #[serde(rename = "cultnet.discovery_probe.v0", rename_all = "camelCase")] + Probe { + message_id: String, + requester_runtime_id: String, + }, + #[serde(rename = "cultnet.discovery_announce.v0", rename_all = "camelCase")] + Announce { + message_id: String, + runtime_id: String, + runtime_kind: String, + display_name: String, + agent_id: Option, + tcp_host: String, + tcp_port: u16, + wire_contract: String, + supported_document_types: Vec, + supports_schema_catalog: bool, + }, +} + +#[derive(Clone, Debug)] +struct PeerConfig { + runtime_id: String, + runtime_kind: String, + display_name: String, + agent_id: String, + bind_host: String, + advertise_host: String, + tcp_port: u16, + discovery_port: u16, + discovery_group: Ipv4Addr, + schema_path: String, +} + +#[derive(Clone, Debug)] +struct DialConfig { + runtime_id: String, + runtime_kind: String, + display_name: String, + agent_id: String, + target_host: String, + target_port: u16, + schema_path: String, +} + +fn main() -> Result<()> { + let mut args = std::env::args().skip(1); + let mode = args + .next() + .ok_or_else(|| anyhow!("expected mode: serve | probe | dial"))?; + let options = parse_args(args.collect()); + + match mode.as_str() { + "serve" => serve(parse_peer_config(&options)?)?, + "probe" => probe(&options)?, + "dial" => dial(parse_dial_config(&options)?)?, + _ => return Err(anyhow!("unknown mode {mode}")), + } + + Ok(()) +} + +fn serve(config: PeerConfig) -> Result<()> { + let schema_registration = load_schema_registration(&config.schema_path)?; + let mut schema_registry = builtin_schema_registry()?; + schema_registry.register(schema_registration.clone())?; + + let mut cache = CultCache::new(); + cache.register_entry_type::()?; + register_capability_entry_types(&mut cache)?; + cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(runtime_store_path( + &config.runtime_id, + ))); + cache.pull_all_backing_stores()?; + let note = build_note(&config.runtime_id, &config.display_name); + cache.put(¬e.document_id, ¬e)?; + + let mut document_registry = CultNetDocumentRegistry::new(); + register_capability_bindings(&mut document_registry, &schema_registration.schema_id); + + let cache = Arc::new(Mutex::new(cache)); + let document_registry = Arc::new(document_registry); + let schema_registry = Arc::new(schema_registry); + let config = Arc::new(config); + + start_udp_discovery_server(config.clone())?; + start_tcp_server(config.clone(), cache, document_registry, schema_registry)?; + + print_json(&serde_json::json!({ + "status": "ready", + "mode": "serve", + "runtimeId": config.runtime_id, + "runtimeKind": config.runtime_kind, + "tcpPort": config.tcp_port, + "discoveryPort": config.discovery_port, + "discoveryGroup": config.discovery_group.to_string(), + }))?; + + loop { + thread::sleep(Duration::from_secs(3600)); + } +} + +fn probe(options: &BTreeMap) -> Result<()> { + let runtime_id = require_arg(options, "runtime-id")?.to_string(); + let discovery_port = parse_u16_arg(options, "discovery-port")?; + let discovery_group = parse_ipv4_arg(options, "discovery-group")?; + let timeout_ms = parse_u64_arg(options, "timeout-ms").unwrap_or(1_500); + let message_id = format!("{runtime_id}-{}", chrono::Utc::now().timestamp_millis()); + + let socket = create_discovery_socket(0, false)?; + socket.set_read_timeout(Some(Duration::from_millis(timeout_ms)))?; + + let probe_message = DiscoveryMessage::Probe { + message_id: message_id.clone(), + requester_runtime_id: runtime_id.clone(), + }; + let payload = rmp_serde::to_vec_named(&probe_message)?; + socket.send_to( + &payload, + SocketAddr::V4(SocketAddrV4::new(discovery_group, discovery_port)), + )?; + + let mut buffer = vec![0_u8; 4096]; + let mut found = BTreeMap::::new(); + loop { + match socket.recv_from(&mut buffer) { + Ok((len, _)) => { + if let Ok(DiscoveryMessage::Announce { + message_id: response_message_id, + runtime_id, + runtime_kind, + display_name, + agent_id, + tcp_host, + tcp_port, + wire_contract, + supported_document_types, + supports_schema_catalog, + }) = rmp_serde::from_slice::(&buffer[..len]) + { + if response_message_id == message_id { + found.insert( + runtime_id.clone(), + serde_json::json!({ + "schemaVersion": DISCOVERY_ANNOUNCE_SCHEMA_VERSION, + "messageId": response_message_id, + "runtimeId": runtime_id, + "runtimeKind": runtime_kind, + "displayName": display_name, + "agentId": agent_id, + "tcpHost": tcp_host, + "tcpPort": tcp_port, + "wireContract": wire_contract, + "supportedDocumentTypes": supported_document_types, + "supportsSchemaCatalog": supports_schema_catalog, + }), + ); + } + } + } + Err(error) + if error.kind() == std::io::ErrorKind::WouldBlock + || error.kind() == std::io::ErrorKind::TimedOut => + { + break; + } + Err(error) => return Err(error.into()), + } + } + + print_json(&serde_json::json!({ + "mode": "probe", + "runtimeId": runtime_id, + "peers": found.into_values().collect::>(), + }))?; + Ok(()) +} + +fn dial(config: DialConfig) -> Result<()> { + let schema_registration = load_schema_registration(&config.schema_path)?; + + let mut cache = CultCache::new(); + cache.register_entry_type::()?; + register_capability_entry_types(&mut cache)?; + cache.add_generic_backing_store(SingleFileMessagePackBackingStore::new(runtime_store_path( + &format!("{}-dial", config.runtime_id), + ))); + cache.pull_all_backing_stores()?; + + let mut document_registry = CultNetDocumentRegistry::new(); + register_capability_bindings(&mut document_registry, &schema_registration.schema_id); + + let mut stream = TcpStream::connect((config.target_host.as_str(), config.target_port)) + .with_context(|| { + format!( + "failed to connect to {}:{}", + config.target_host, config.target_port + ) + })?; + + send_message( + &mut stream, + &CultNetMessage::Hello { + runtime_id: config.runtime_id.clone(), + runtime_kind: config.runtime_kind.clone(), + agent_id: Some(config.agent_id.clone()), + role: None, + display_name: Some(config.display_name.clone()), + supported_document_types: Some(vec![INTEROP_DOCUMENT_TYPE.to_string()]), + supported_mutation_contracts: Some(interaction_contracts()), + supported_message_versions: Some(vec![INTEROP_SCHEMA_VERSION.to_string()]), + transport_profiles: Some(tcp_framed_transport_profiles( + &config.runtime_id, + None, + None, + None, + )), + supports_schema_catalog: Some(true), + }, + )?; + + let remote_hello = read_message(&mut stream)?; + let remote_runtime_id = match &remote_hello { + CultNetMessage::Hello { runtime_id, .. } => runtime_id.clone(), + other => return Err(anyhow!("expected hello response, got {other:?}")), + }; + + send_message( + &mut stream, + &CultNetMessage::SchemaCatalogRequest { + message_id: format!("{}-catalog", config.runtime_id), + include_schema_json: Some(true), + schema_ids: None, + kinds: None, + }, + )?; + let catalog_response = read_message(&mut stream)?; + let has_interop_schema = match &catalog_response { + CultNetMessage::SchemaCatalogResponse { schemas, .. } => schemas.iter().any(|schema| { + schema.schema_id == schema_registration.schema_id + && schema.document_type.as_deref() == Some(INTEROP_DOCUMENT_TYPE) + }), + other => return Err(anyhow!("expected catalog response, got {other:?}")), + }; + + send_message( + &mut stream, + &CultNetMessage::SnapshotRequest { + message_id: format!("{}-snapshot", config.runtime_id), + schema_ids: Some(vec![schema_registration.schema_id.clone()]), + record_keys: None, + }, + )?; + let snapshot_response = read_message(&mut stream)?; + let applied = document_registry + .apply_raw_snapshot_response::(&mut cache, &snapshot_response)?; + let note = applied + .into_iter() + .find(|candidate| candidate.author_runtime_id == remote_runtime_id) + .ok_or_else(|| anyhow!("did not receive an interop note from {remote_runtime_id}"))?; + + print_json(&serde_json::json!({ + "mode": "dial", + "runtimeId": config.runtime_id, + "targetHost": config.target_host, + "targetPort": config.target_port, + "remoteHello": { + "schemaVersion": "cultnet.hello.v0", + "runtimeId": remote_runtime_id, + }, + "hasInteropSchema": has_interop_schema, + "retrievedNote": { + "schemaVersion": note.schema_version, + "documentId": note.document_id, + "authorRuntimeId": note.author_runtime_id, + "title": note.title, + "body": note.body, + "tags": note.tags, + }, + "mutatedNote": mutate_remote_note(&mut stream, &mut cache, &document_registry, &schema_registration.schema_id, &config.runtime_id, ¬e)?, + "fireReceipt": fire_remote_weapon(&mut stream, &mut cache, &document_registry, &config.runtime_id, &remote_runtime_id)?, + }))?; + Ok(()) +} + +fn mutate_remote_note( + stream: &mut TcpStream, + cache: &mut CultCache, + document_registry: &CultNetDocumentRegistry, + note_schema_id: &str, + runtime_id: &str, + note: &CultNetInteropNote, +) -> Result { + let intent = CultNetInteropMutationIntent { + schema_version: MUTATION_INTENT_SCHEMA_VERSION.to_string(), + intent_id: format!("{runtime_id}-decorate"), + target_document_id: note.document_id.clone(), + append_body: format!(" Decorated by {runtime_id}."), + append_tag: format!("decorated:{runtime_id}"), + }; + let message = document_registry.create_raw_document_put_message( + format!("{runtime_id}-decorate-put"), + intent.intent_id.clone(), + &intent, + CultNetDocumentPutOptions::default(), + )?; + send_message(stream, &message)?; + + let receipt_message = read_message(stream)?; + let _receipt = document_registry + .apply_raw_document_put_message::(cache, &receipt_message)?; + let mutated_message = read_message(stream)?; + let mutated = document_registry + .apply_raw_document_put_message::(cache, &mutated_message)?; + if mutated_message_schema_id(&mutated_message) != Some(note_schema_id) { + return Err(anyhow!("mutation response used the wrong schema id")); + } + Ok(serde_json::json!({ + "schemaVersion": mutated.schema_version, + "documentId": mutated.document_id, + "authorRuntimeId": mutated.author_runtime_id, + "title": mutated.title, + "body": mutated.body, + "tags": mutated.tags, + })) +} + +fn fire_remote_weapon( + stream: &mut TcpStream, + cache: &mut CultCache, + document_registry: &CultNetDocumentRegistry, + runtime_id: &str, + remote_runtime_id: &str, +) -> Result { + let command = CultNetInteropFireCommand { + schema_version: FIRE_COMMAND_SCHEMA_VERSION.to_string(), + command_id: format!("{runtime_id}-fire"), + character_id: remote_runtime_id.to_string(), + weapon_id: "interop-rifle".to_string(), + }; + let message = document_registry.create_raw_document_put_message( + format!("{runtime_id}-fire-put"), + command.command_id.clone(), + &command, + CultNetDocumentPutOptions::default(), + )?; + send_message(stream, &message)?; + let receipt_message = read_message(stream)?; + let receipt = document_registry + .apply_raw_document_put_message::(cache, &receipt_message)?; + Ok(serde_json::json!({ + "schemaVersion": receipt.schema_version, + "commandId": receipt.command_id, + "accepted": receipt.accepted, + "characterId": receipt.character_id, + "weaponId": receipt.weapon_id, + "shotsFired": receipt.shots_fired, + "ammoRemaining": receipt.ammo_remaining, + })) +} + +fn start_udp_discovery_server(config: Arc) -> Result<()> { + let socket = create_discovery_socket(config.discovery_port, true)?; + socket.join_multicast_v4(&config.discovery_group, &Ipv4Addr::UNSPECIFIED)?; + socket.set_read_timeout(Some(Duration::from_millis(250)))?; + + thread::spawn(move || { + let mut buffer = vec![0_u8; 4096]; + loop { + match socket.recv_from(&mut buffer) { + Ok((len, remote)) => { + if let Ok(DiscoveryMessage::Probe { + message_id, + requester_runtime_id: _, + }) = rmp_serde::from_slice::(&buffer[..len]) + { + let announce = DiscoveryMessage::Announce { + message_id, + runtime_id: config.runtime_id.clone(), + runtime_kind: config.runtime_kind.clone(), + display_name: config.display_name.clone(), + agent_id: Some(config.agent_id.clone()), + tcp_host: config.advertise_host.clone(), + tcp_port: config.tcp_port, + wire_contract: "cultnet.schema.v0".to_string(), + supported_document_types: vec![INTEROP_DOCUMENT_TYPE.to_string()], + supports_schema_catalog: true, + }; + if let Ok(payload) = rmp_serde::to_vec_named(&announce) { + let _ = socket.send_to(&payload, remote); + } + } + } + Err(error) + if error.kind() == std::io::ErrorKind::WouldBlock + || error.kind() == std::io::ErrorKind::TimedOut => {} + Err(_) => break, + } + } + }); + + Ok(()) +} + +fn start_tcp_server( + config: Arc, + cache: Arc>, + document_registry: Arc, + schema_registry: Arc, +) -> Result<()> { + let listener = + TcpListener::bind((config.bind_host.as_str(), config.tcp_port)).with_context(|| { + format!( + "failed to bind TCP listener on {}:{}", + config.bind_host, config.tcp_port + ) + })?; + listener.set_nonblocking(false)?; + + thread::spawn(move || { + for stream in listener.incoming() { + let Ok(stream) = stream else { + continue; + }; + let config = config.clone(); + let cache = cache.clone(); + let document_registry = document_registry.clone(); + let schema_registry = schema_registry.clone(); + thread::spawn(move || { + if let Err(error) = + handle_connection(stream, config, cache, document_registry, schema_registry) + { + eprintln!("{error:#}"); + } + }); + } + }); + + Ok(()) +} + +fn handle_connection( + mut stream: TcpStream, + config: Arc, + cache: Arc>, + document_registry: Arc, + schema_registry: Arc, +) -> Result<()> { + loop { + let message = match read_message(&mut stream) { + Ok(message) => message, + Err(error) if is_eof_like(&error) => break, + Err(error) => return Err(error), + }; + + match message { + CultNetMessage::Hello { .. } => { + send_message( + &mut stream, + &CultNetMessage::Hello { + runtime_id: config.runtime_id.clone(), + runtime_kind: config.runtime_kind.clone(), + agent_id: Some(config.agent_id.clone()), + role: None, + display_name: Some(config.display_name.clone()), + supported_document_types: Some(vec![INTEROP_DOCUMENT_TYPE.to_string()]), + supported_mutation_contracts: Some(interaction_contracts()), + supported_message_versions: Some(vec![INTEROP_SCHEMA_VERSION.to_string()]), + transport_profiles: Some(tcp_framed_transport_profiles( + &config.runtime_id, + Some(&config.advertise_host), + Some(config.tcp_port), + Some(config.discovery_group), + )), + supports_schema_catalog: Some(true), + }, + )?; + } + request @ CultNetMessage::SchemaCatalogRequest { .. } => { + let response = schema_registry.create_catalog_response(&request)?; + send_message(&mut stream, &response)?; + } + CultNetMessage::SnapshotRequest { + message_id, + schema_ids, + record_keys, + } => { + let mut response = document_registry.create_raw_snapshot_response( + &cache.lock().expect("cache poisoned"), + message_id, + schema_ids.as_deref(), + record_keys.as_deref(), + )?; + if let CultNetMessage::SnapshotResponseRaw { documents, .. } = &mut response { + for document in documents.iter_mut() { + document.source_runtime_id = Some(config.runtime_id.clone()); + document.source_agent_id = Some(config.agent_id.clone()); + document.source_role = Some("peer".to_string()); + document.tags = + Some(vec!["interop".to_string(), config.runtime_id.clone()]); + } + } + send_message(&mut stream, &response)?; + } + message @ CultNetMessage::DocumentPutRaw { .. } => { + handle_raw_put(&mut stream, &config, &cache, &document_registry, &message)?; + } + _ => {} + } + } + + Ok(()) +} + +fn handle_raw_put( + stream: &mut TcpStream, + config: &PeerConfig, + cache: &Arc>, + document_registry: &CultNetDocumentRegistry, + message: &CultNetMessage, +) -> Result<()> { + let CultNetMessage::DocumentPutRaw { document, .. } = message else { + return Ok(()); + }; + if document.schema_id == MUTATION_INTENT_SCHEMA_ID { + let mut cache = cache.lock().expect("cache poisoned"); + let intent = document_registry + .apply_raw_document_put_message::(&mut cache, message)?; + let mut note = cache.get_required::(&intent.target_document_id)?; + note.body = format!("{}{}", note.body, intent.append_body); + note.tags.push(intent.append_tag); + cache.put(¬e.document_id, ¬e)?; + let receipt = CultNetInteropMutationReceipt { + schema_version: MUTATION_RECEIPT_SCHEMA_VERSION.to_string(), + intent_id: intent.intent_id.clone(), + accepted: true, + document_id: note.document_id.clone(), + body: note.body.clone(), + tags: note.tags.clone(), + }; + let options = response_options(config, "mutation"); + let receipt_message = document_registry.create_raw_document_put_message( + format!("{}-mutation-receipt", config.runtime_id), + receipt.intent_id.clone(), + &receipt, + options.clone(), + )?; + let note_message = document_registry.create_raw_document_put_message( + format!("{}-mutated-note", config.runtime_id), + note.document_id.clone(), + ¬e, + options, + )?; + send_message(stream, &receipt_message)?; + send_message(stream, ¬e_message)?; + } else if document.schema_id == FIRE_COMMAND_SCHEMA_ID { + let mut cache = cache.lock().expect("cache poisoned"); + let command = document_registry + .apply_raw_document_put_message::(&mut cache, message)?; + let receipt = CultNetInteropFireReceipt { + schema_version: FIRE_RECEIPT_SCHEMA_VERSION.to_string(), + command_id: command.command_id, + accepted: true, + character_id: command.character_id, + weapon_id: command.weapon_id, + shots_fired: 1, + ammo_remaining: 29, + }; + let receipt_message = document_registry.create_raw_document_put_message( + format!("{}-fire-receipt", config.runtime_id), + receipt.command_id.clone(), + &receipt, + response_options(config, "side-effect"), + )?; + send_message(stream, &receipt_message)?; + } + Ok(()) +} + +fn load_schema_registration(schema_path: &str) -> Result { + let schema_json = fs::read_to_string(schema_path) + .with_context(|| format!("failed to read schema {}", schema_path))?; + let parsed: serde_json::Value = serde_json::from_str(&schema_json) + .with_context(|| format!("failed to parse schema {}", schema_path))?; + let schema_id = parsed + .get("$id") + .and_then(serde_json::Value::as_str) + .ok_or_else(|| anyhow!("schema {} is missing $id", schema_path))? + .to_string(); + let title = parsed + .get("title") + .and_then(serde_json::Value::as_str) + .map(ToString::to_string); + + Ok(CultNetSchemaRegistration { + schema_id, + kind: CultNetSchemaKind::DocumentPayload, + wire_contracts: vec![CultNetWireContract::CultNetSchemaV0], + schema_version: Some(INTEROP_SCHEMA_VERSION.to_string()), + document_type: Some(INTEROP_DOCUMENT_TYPE.to_string()), + title, + schema_json: Some(schema_json), + }) +} + +fn register_capability_entry_types(cache: &mut CultCache) -> Result<()> { + cache.register_entry_type::()?; + cache.register_entry_type::()?; + cache.register_entry_type::()?; + cache.register_entry_type::()?; + Ok(()) +} + +fn register_capability_bindings( + document_registry: &mut CultNetDocumentRegistry, + note_schema_id: &str, +) { + document_registry + .register(CultNetDocumentBinding::for_entry_with_schema_id::< + CultNetInteropNote, + >( + note_schema_id.to_string(), + INTEROP_SCHEMA_VERSION.to_string(), + )) + .register(CultNetDocumentBinding::for_entry_with_schema_id::< + CultNetInteropMutationIntent, + >( + MUTATION_INTENT_SCHEMA_ID.to_string(), + MUTATION_INTENT_SCHEMA_VERSION.to_string(), + )) + .register(CultNetDocumentBinding::for_entry_with_schema_id::< + CultNetInteropMutationReceipt, + >( + MUTATION_RECEIPT_SCHEMA_ID.to_string(), + MUTATION_RECEIPT_SCHEMA_VERSION.to_string(), + )) + .register(CultNetDocumentBinding::for_entry_with_schema_id::< + CultNetInteropFireCommand, + >( + FIRE_COMMAND_SCHEMA_ID.to_string(), + FIRE_COMMAND_SCHEMA_VERSION.to_string(), + )) + .register(CultNetDocumentBinding::for_entry_with_schema_id::< + CultNetInteropFireReceipt, + >( + FIRE_RECEIPT_SCHEMA_ID.to_string(), + FIRE_RECEIPT_SCHEMA_VERSION.to_string(), + )); +} + +fn interaction_contracts() -> Vec { + vec![CultNetDocumentMutationContract { + document_type: INTEROP_DOCUMENT_TYPE.to_string(), + payload_schema_version: Some(INTEROP_SCHEMA_VERSION.to_string()), + operations: vec![ + CultNetDocumentOperation::Snapshot, + CultNetDocumentOperation::DocumentPut, + CultNetDocumentOperation::IntentSubmit, + CultNetDocumentOperation::ReceiptWatch, + ], + authority: CultNetMutationAuthority::Runtime, + intent_document_types: Some(vec![ + MUTATION_INTENT_TYPE.to_string(), + FIRE_COMMAND_TYPE.to_string(), + ]), + receipt_document_types: Some(vec![ + MUTATION_RECEIPT_TYPE.to_string(), + FIRE_RECEIPT_TYPE.to_string(), + ]), + notes: None, + }] +} + +fn tcp_framed_transport_profiles( + runtime_id: &str, + host: Option<&str>, + port: Option, + discovery_group: Option, +) -> Vec { + vec![CultNetTransportProfile { + schema_version: "cultnet.transport_profile.v0".to_string(), + runtime_id: runtime_id.to_string(), + transports: vec![CultNetTransportDescriptor { + transport_id: "interop-tcp-framed".to_string(), + protocol: CultNetTransportProtocol::TcpFramed, + host: host.map(ToString::to_string), + port, + path: None, + discovery_group: discovery_group.map(|group| group.to_string()), + 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, + reliable_expire_after_ms: None, + }, + CultNetTransportChannel { + channel_id: "state".to_string(), + delivery: CultNetTransportDelivery::Reliable, + ordering: CultNetTransportOrdering::Ordered, + max_payload_bytes: None, + max_fragment_bytes: None, + max_pending_reliable_packets: None, + reliable_expire_after_ms: None, + }, + ], + }], + }] +} + +fn response_options(config: &PeerConfig, tag: &str) -> CultNetDocumentPutOptions { + CultNetDocumentPutOptions { + source_runtime_id: Some(config.runtime_id.clone()), + source_agent_id: Some(config.agent_id.clone()), + source_role: Some("peer".to_string()), + tags: Some(vec![tag.to_string(), config.runtime_id.clone()]), + ..CultNetDocumentPutOptions::default() + } +} + +fn mutated_message_schema_id(message: &CultNetMessage) -> Option<&str> { + match message { + CultNetMessage::DocumentPutRaw { document, .. } => Some(document.schema_id.as_str()), + _ => None, + } +} + +fn build_note(runtime_id: &str, display_name: &str) -> CultNetInteropNote { + CultNetInteropNote { + schema_version: INTEROP_SCHEMA_VERSION.to_string(), + document_id: format!("note:{runtime_id}"), + author_runtime_id: runtime_id.to_string(), + title: format!("{display_name} keeps a little note"), + body: format!( + "{runtime_id} can move CultNet state without begging the gods for translation." + ), + tags: vec![ + runtime_id.to_string(), + "interop".to_string(), + "cultnet".to_string(), + ], + } +} + +fn send_message(stream: &mut TcpStream, message: &CultNetMessage) -> Result<()> { + let payload = encode_cultnet_message_to_vec(message, CultNetWireContract::CultNetSchemaV0)?; + let frame = encode_frame(&payload)?; + stream.write_all(&frame)?; + stream.flush()?; + Ok(()) +} + +fn read_message(stream: &mut TcpStream) -> Result { + let mut header = [0_u8; 4]; + stream.read_exact(&mut header)?; + let payload_len = u32::from_be_bytes(header) as usize; + let mut payload = vec![0_u8; payload_len]; + stream.read_exact(&mut payload)?; + decode_cultnet_message_from_slice(&payload, CultNetWireContract::CultNetSchemaV0) +} + +fn is_eof_like(error: &anyhow::Error) -> bool { + error + .downcast_ref::() + .is_some_and(|io| io.kind() == std::io::ErrorKind::UnexpectedEof) +} + +fn create_discovery_socket(port: u16, _join_group: bool) -> Result { + let socket = Socket::new(Domain::IPV4, Type::DGRAM, Some(Protocol::UDP))?; + socket.set_reuse_address(true)?; + socket.bind(&SocketAddrV4::new(Ipv4Addr::UNSPECIFIED, port).into())?; + let socket = UdpSocket::from(socket); + socket.set_multicast_loop_v4(true)?; + socket.set_multicast_ttl_v4(1)?; + socket.set_nonblocking(false)?; + Ok(socket) +} + +fn parse_peer_config(options: &BTreeMap) -> Result { + Ok(PeerConfig { + runtime_id: require_arg(options, "runtime-id")?.to_string(), + runtime_kind: require_arg(options, "runtime-kind")?.to_string(), + display_name: require_arg(options, "display-name")?.to_string(), + agent_id: require_arg(options, "agent-id")?.to_string(), + bind_host: options + .get("bind-host") + .cloned() + .unwrap_or_else(|| "127.0.0.1".to_string()), + advertise_host: require_arg(options, "advertise-host")?.to_string(), + tcp_port: parse_u16_arg(options, "tcp-port")?, + discovery_port: parse_u16_arg(options, "discovery-port")?, + discovery_group: parse_ipv4_arg(options, "discovery-group")?, + schema_path: require_arg(options, "schema-path")?.to_string(), + }) +} + +fn parse_dial_config(options: &BTreeMap) -> Result { + Ok(DialConfig { + runtime_id: require_arg(options, "runtime-id")?.to_string(), + runtime_kind: require_arg(options, "runtime-kind")?.to_string(), + display_name: require_arg(options, "display-name")?.to_string(), + agent_id: require_arg(options, "agent-id")?.to_string(), + target_host: require_arg(options, "target-host")?.to_string(), + target_port: parse_u16_arg(options, "target-port")?, + schema_path: require_arg(options, "schema-path")?.to_string(), + }) +} + +fn parse_args(args: Vec) -> BTreeMap { + let mut parsed = BTreeMap::new(); + let mut index = 0; + while index < args.len() { + let token = &args[index]; + if !token.starts_with("--") { + index += 1; + continue; + } + let name = token.trim_start_matches("--").to_string(); + let value = args + .get(index + 1) + .cloned() + .unwrap_or_else(|| panic!("missing value for --{name}")); + parsed.insert(name, value); + index += 2; + } + parsed +} + +fn require_arg<'a>(options: &'a BTreeMap, name: &str) -> Result<&'a str> { + options + .get(name) + .map(String::as_str) + .ok_or_else(|| anyhow!("missing required argument --{name}")) +} + +fn parse_u16_arg(options: &BTreeMap, name: &str) -> Result { + require_arg(options, name)? + .parse::() + .with_context(|| format!("argument --{name} must be a u16")) +} + +fn parse_u64_arg(options: &BTreeMap, name: &str) -> Option { + options + .get(name) + .map(|value| value.parse::().expect("u64 arg")) +} + +fn parse_ipv4_arg(options: &BTreeMap, name: &str) -> Result { + require_arg(options, name)? + .parse::() + .with_context(|| format!("argument --{name} must be an IPv4 address")) +} + +fn runtime_store_path(runtime_id: &str) -> std::path::PathBuf { + std::env::temp_dir().join(format!("cultnet-rs-interop-{runtime_id}.cc")) +} + +fn print_json(value: &serde_json::Value) -> Result<()> { + println!("{}", serde_json::to_string(value)?); + Ok(()) +} diff --git a/vendor/cultnet-rs/src/contracts.rs b/vendor/cultnet-rs/src/contracts.rs new file mode 100644 index 0000000..460764d --- /dev/null +++ b/vendor/cultnet-rs/src/contracts.rs @@ -0,0 +1,1224 @@ +use anyhow::Result; +use anyhow::anyhow; +use base64::Engine; +use base64::engine::general_purpose::URL_SAFE_NO_PAD; +use serde::Deserialize; +use serde::Serialize; +use serde_json::Value; + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +pub enum CultNetWireContract { + #[serde(rename = "cultnet.schema.v0")] + CultNetSchemaV0, + #[serde(rename = "gamecult.networking.v0")] + GameCultNetworkingV0, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum CultNetSchemaKind { + WireMessage, + DocumentPayload, + SharedContract, +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum CultNetRawPayloadEncoding { + Messagepack, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct CultNetDocumentRecord { + pub schema_id: String, + pub record_key: String, + pub stored_at: String, + pub payload: TPayload, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_runtime_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_agent_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_role: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub tags: Option>, +} + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum CultNetDocumentOperation { + Snapshot, + DocumentPut, + DocumentDelete, + IntentSubmit, + ReceiptWatch, +} + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum CultNetMutationAuthority { + ReadOnly, + LocalUser, + Coordinator, + Runtime, + Denied, +} + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct CultNetDocumentMutationContract { + pub document_type: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub payload_schema_version: Option, + pub operations: Vec, + pub authority: CultNetMutationAuthority, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub intent_document_types: Option>, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub receipt_document_types: Option>, + #[serde(default, skip_serializing_if = "Option::is_none")] + 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, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub reliable_expire_after_ms: 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 { + pub schema_id: String, + pub record_key: String, + pub stored_at: String, + pub payload_encoding: CultNetRawPayloadEncoding, + #[serde(with = "serde_bytes")] + pub payload: Vec, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_runtime_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_agent_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub source_role: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub tags: Option>, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct CultNetSchemaDescriptor { + pub schema_id: String, + pub kind: CultNetSchemaKind, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub schema_version: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub document_type: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub title: Option, + pub wire_contracts: Vec, + pub content_hash: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub schema_json: Option, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +#[serde(tag = "schemaVersion")] +pub enum CultNetMessage { + #[serde(rename = "cultnet.hello.v0", rename_all = "camelCase")] + Hello { + runtime_id: String, + runtime_kind: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + agent_id: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + role: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + display_name: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + supported_document_types: Option>, + #[serde(default, skip_serializing_if = "Option::is_none")] + supported_mutation_contracts: Option>, + #[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")] + Login { + nonce: String, + auth: String, + password: String, + }, + #[serde(rename = "cultnet.register.v0", rename_all = "camelCase")] + Register { + nonce: String, + email: String, + password: String, + name: String, + }, + #[serde(rename = "cultnet.verify.v0", rename_all = "camelCase")] + Verify { nonce: String, session: String }, + #[serde(rename = "cultnet.login_success.v0", rename_all = "camelCase")] + LoginSuccess { nonce: String, session: String }, + #[serde(rename = "cultnet.error.v0", rename_all = "camelCase")] + Error { error: String }, + #[serde(rename = "cultnet.sample.change_name.v0", rename_all = "camelCase")] + SampleChangeName { name: String }, + #[serde(rename = "cultnet.sample.chat.v0", rename_all = "camelCase")] + SampleChat { text: String }, + #[serde(rename = "cultnet.document_put.v0", rename_all = "camelCase")] + DocumentPut { + message_id: String, + document: CultNetDocumentRecord, + }, + #[serde(rename = "cultnet.document_delete.v0", rename_all = "camelCase")] + DocumentDelete { + message_id: String, + schema_id: String, + record_key: String, + }, + #[serde(rename = "cultnet.document_put_raw.v0", rename_all = "camelCase")] + DocumentPutRaw { + message_id: String, + document: CultNetRawDocumentRecord, + }, + #[serde(rename = "cultnet.snapshot_request.v0", rename_all = "camelCase")] + SnapshotRequest { + message_id: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + schema_ids: Option>, + #[serde(default, skip_serializing_if = "Option::is_none")] + record_keys: Option>, + }, + #[serde(rename = "cultnet.snapshot_response.v0", rename_all = "camelCase")] + SnapshotResponse { + message_id: String, + documents: Vec>, + }, + #[serde(rename = "cultnet.snapshot_response_raw.v0", rename_all = "camelCase")] + SnapshotResponseRaw { + message_id: String, + documents: Vec, + }, + #[serde(rename = "cultnet.schema_catalog_request.v0", rename_all = "camelCase")] + SchemaCatalogRequest { + message_id: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + include_schema_json: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + schema_ids: Option>, + #[serde(default, skip_serializing_if = "Option::is_none")] + kinds: Option>, + }, + #[serde( + rename = "cultnet.schema_catalog_response.v0", + rename_all = "camelCase" + )] + SchemaCatalogResponse { + message_id: String, + schemas: Vec, + }, +} + +pub fn parse_cultnet_message( + wire_value: &rmpv::Value, + contract: CultNetWireContract, +) -> Result { + match contract { + CultNetWireContract::CultNetSchemaV0 => { + let message = match schema_version_from_wire_value(wire_value)? { + Some("cultnet.document_put_raw.v0" | "cultnet.snapshot_response_raw.v0") => { + parse_raw_cultnet_schema_message(wire_value)? + } + _ => { + let json_value: Value = rmp_serde::from_slice(&rmp_serde::to_vec(wire_value)?)?; + serde_json::from_value(json_value)? + } + }; + validate_message(&message)?; + Ok(message) + } + CultNetWireContract::GameCultNetworkingV0 => parse_gamecult_networking_message(wire_value), + } +} + +pub fn encode_cultnet_message_for_wire( + message: &CultNetMessage, + contract: CultNetWireContract, +) -> Result { + validate_message(message)?; + match contract { + CultNetWireContract::CultNetSchemaV0 => match message { + CultNetMessage::DocumentPutRaw { .. } | CultNetMessage::SnapshotResponseRaw { .. } => { + encode_raw_cultnet_schema_message(message) + } + _ => Ok(rmp_serde::from_slice(&rmp_serde::to_vec( + &serde_json::to_value(message)?, + )?)?), + }, + CultNetWireContract::GameCultNetworkingV0 => encode_gamecult_networking_message(message), + } +} + +pub fn encode_cultnet_message_to_vec( + message: &CultNetMessage, + contract: CultNetWireContract, +) -> Result> { + let wire_value = encode_cultnet_message_for_wire(message, contract)?; + Ok(rmp_serde::to_vec(&wire_value)?) +} + +pub fn decode_cultnet_message_from_slice( + bytes: &[u8], + contract: CultNetWireContract, +) -> Result { + if contract == CultNetWireContract::CultNetSchemaV0 { + let wire_value: rmpv::Value = rmp_serde::from_slice(bytes)?; + return parse_cultnet_message(&wire_value, contract); + } + let wire_value: rmpv::Value = rmp_serde::from_slice(bytes)?; + parse_cultnet_message(&wire_value, contract) +} + +fn validate_message(message: &CultNetMessage) -> Result<()> { + match message { + CultNetMessage::Hello { + runtime_id, + runtime_kind, + agent_id, + role, + display_name, + supported_document_types, + supported_mutation_contracts, + supported_message_versions, + transport_profiles: _, + supports_schema_catalog: _, + } => { + require_non_empty(runtime_id, "runtimeId")?; + require_non_empty(runtime_kind, "runtimeKind")?; + require_optional_non_empty(agent_id.as_deref(), "agentId")?; + require_optional_non_empty(role.as_deref(), "role")?; + require_optional_non_empty(display_name.as_deref(), "displayName")?; + require_optional_string_vec( + supported_document_types.as_deref(), + "supportedDocumentTypes", + )?; + if let Some(contracts) = supported_mutation_contracts { + for contract in contracts { + validate_mutation_contract(contract)?; + } + } + require_optional_string_vec( + supported_message_versions.as_deref(), + "supportedMessageVersions", + )?; + } + CultNetMessage::Login { + nonce, + auth, + password, + } => { + require_non_empty(nonce, "nonce")?; + require_non_empty(auth, "auth")?; + require_non_empty(password, "password")?; + } + CultNetMessage::Register { + nonce, + email, + password, + name, + } => { + require_non_empty(nonce, "nonce")?; + require_non_empty(email, "email")?; + require_non_empty(password, "password")?; + require_non_empty(name, "name")?; + } + CultNetMessage::Verify { nonce, session } + | CultNetMessage::LoginSuccess { nonce, session } => { + require_non_empty(nonce, "nonce")?; + require_non_empty(session, "session")?; + } + CultNetMessage::Error { error } => require_non_empty(error, "error")?, + CultNetMessage::SampleChangeName { name } => require_non_empty(name, "name")?, + CultNetMessage::SampleChat { text } => require_non_empty(text, "text")?, + CultNetMessage::DocumentPut { + message_id, + document, + } => { + require_non_empty(message_id, "messageId")?; + validate_document_record(document)?; + } + CultNetMessage::DocumentDelete { + message_id, + schema_id, + record_key, + } => { + require_non_empty(message_id, "messageId")?; + require_non_empty(schema_id, "schemaId")?; + require_non_empty(record_key, "recordKey")?; + } + CultNetMessage::DocumentPutRaw { + message_id, + document, + } => { + require_non_empty(message_id, "messageId")?; + validate_raw_document_record(document)?; + } + CultNetMessage::SnapshotRequest { + message_id, + schema_ids, + record_keys, + } => { + require_non_empty(message_id, "messageId")?; + require_optional_string_vec(schema_ids.as_deref(), "schemaIds")?; + require_optional_string_vec(record_keys.as_deref(), "recordKeys")?; + } + CultNetMessage::SnapshotResponse { + message_id, + documents, + } => { + require_non_empty(message_id, "messageId")?; + for document in documents { + validate_document_record(document)?; + } + } + CultNetMessage::SnapshotResponseRaw { + message_id, + documents, + } => { + require_non_empty(message_id, "messageId")?; + for document in documents { + validate_raw_document_record(document)?; + } + } + CultNetMessage::SchemaCatalogRequest { + message_id, + include_schema_json: _, + schema_ids, + kinds: _, + } => { + require_non_empty(message_id, "messageId")?; + require_optional_string_vec(schema_ids.as_deref(), "schemaIds")?; + } + CultNetMessage::SchemaCatalogResponse { + message_id, + schemas, + } => { + require_non_empty(message_id, "messageId")?; + for schema in schemas { + validate_schema_descriptor(schema)?; + } + } + } + Ok(()) +} + +fn validate_mutation_contract(contract: &CultNetDocumentMutationContract) -> Result<()> { + require_non_empty(&contract.document_type, "documentType")?; + require_optional_non_empty( + contract.payload_schema_version.as_deref(), + "payloadSchemaVersion", + )?; + if contract.operations.is_empty() { + return Err(anyhow!( + "CultNet mutation contract for {:?} must advertise at least one operation", + contract.document_type + )); + } + require_optional_string_vec( + contract.intent_document_types.as_deref(), + "intentDocumentTypes", + )?; + require_optional_string_vec( + contract.receipt_document_types.as_deref(), + "receiptDocumentTypes", + )?; + require_optional_string_vec(contract.notes.as_deref(), "notes")?; + Ok(()) +} + +fn validate_document_record(document: &CultNetDocumentRecord) -> Result<()> { + require_non_empty(&document.schema_id, "schemaId")?; + require_non_empty(&document.record_key, "recordKey")?; + require_non_empty(&document.stored_at, "storedAt")?; + require_optional_non_empty(document.source_runtime_id.as_deref(), "sourceRuntimeId")?; + require_optional_non_empty(document.source_agent_id.as_deref(), "sourceAgentId")?; + require_optional_non_empty(document.source_role.as_deref(), "sourceRole")?; + require_optional_string_vec(document.tags.as_deref(), "tags")?; + Ok(()) +} + +fn validate_raw_document_record(document: &CultNetRawDocumentRecord) -> Result<()> { + require_non_empty(&document.schema_id, "schemaId")?; + require_non_empty(&document.record_key, "recordKey")?; + require_non_empty(&document.stored_at, "storedAt")?; + if document.payload.is_empty() { + return Err(anyhow!( + "CultNet field payload must contain non-empty MessagePack bytes" + )); + } + require_optional_non_empty(document.source_runtime_id.as_deref(), "sourceRuntimeId")?; + require_optional_non_empty(document.source_agent_id.as_deref(), "sourceAgentId")?; + require_optional_non_empty(document.source_role.as_deref(), "sourceRole")?; + require_optional_string_vec(document.tags.as_deref(), "tags")?; + Ok(()) +} + +fn validate_schema_descriptor(schema: &CultNetSchemaDescriptor) -> Result<()> { + require_non_empty(&schema.schema_id, "schemaId")?; + require_optional_non_empty(schema.schema_version.as_deref(), "schemaVersion")?; + require_optional_non_empty(schema.document_type.as_deref(), "documentType")?; + require_optional_non_empty(schema.title.as_deref(), "title")?; + require_non_empty(&schema.content_hash, "contentHash")?; + require_optional_non_empty(schema.schema_json.as_deref(), "schemaJson")?; + + if schema.wire_contracts.is_empty() { + return Err(anyhow!( + "CultNet field wireContracts must contain at least one supported contract" + )); + } + + Ok(()) +} + +fn require_non_empty(value: &str, field: &str) -> Result<()> { + if value.trim().is_empty() { + return Err(anyhow!("CultNet field {field} must be non-empty")); + } + Ok(()) +} + +fn require_optional_non_empty(value: Option<&str>, field: &str) -> Result<()> { + if let Some(value) = value { + require_non_empty(value, field)?; + } + Ok(()) +} + +fn require_optional_string_vec(value: Option<&[String]>, field: &str) -> Result<()> { + if let Some(values) = value { + for item in values { + require_non_empty(item, field)?; + } + } + Ok(()) +} + +fn schema_version_from_wire_value(input: &rmpv::Value) -> Result> { + let Some(object) = input.as_map() else { + return Ok(None); + }; + + Ok(object.iter().find_map(|(key, value)| { + key.as_str() + .filter(|candidate| *candidate == "schemaVersion") + .and_then(|_| value.as_str()) + })) +} + +fn parse_raw_cultnet_schema_message(input: &rmpv::Value) -> Result { + let object = input + .as_map() + .ok_or_else(|| anyhow!("cultnet.schema.v0 raw messages must be objects"))?; + + let get = |name: &str| -> Option<&rmpv::Value> { + object.iter().find_map(|(key, value)| { + key.as_str() + .filter(|candidate| *candidate == name) + .map(|_| value) + }) + }; + + let schema_version = require_legacy_string(get("schemaVersion"), "schemaVersion")?; + match schema_version.as_str() { + "cultnet.document_put_raw.v0" => Ok(CultNetMessage::DocumentPutRaw { + message_id: require_legacy_string(get("messageId"), "messageId")?, + document: require_raw_document_record(get("document"), "document")?, + }), + "cultnet.snapshot_response_raw.v0" => { + let documents = get("documents") + .and_then(rmpv::Value::as_array) + .ok_or_else(|| anyhow!("documents must be an array"))? + .iter() + .enumerate() + .map(|(index, value)| { + require_raw_document_record(value.into(), &format!("documents[{index}]")) + }) + .collect::>>()?; + + Ok(CultNetMessage::SnapshotResponseRaw { + message_id: require_legacy_string(get("messageId"), "messageId")?, + documents, + }) + } + _ => Err(anyhow!( + "Unsupported raw cultnet.schema.v0 schemaVersion {schema_version}" + )), + } +} + +fn encode_raw_cultnet_schema_message(message: &CultNetMessage) -> Result { + Ok(rmpv::Value::Map(match message { + CultNetMessage::DocumentPutRaw { + message_id, + document, + } => vec![ + ( + rmpv::Value::from("schemaVersion"), + rmpv::Value::from("cultnet.document_put_raw.v0"), + ), + ( + rmpv::Value::from("messageId"), + rmpv::Value::from(message_id.as_str()), + ), + ( + rmpv::Value::from("document"), + encode_raw_document_record(document), + ), + ], + CultNetMessage::SnapshotResponseRaw { + message_id, + documents, + } => vec![ + ( + rmpv::Value::from("schemaVersion"), + rmpv::Value::from("cultnet.snapshot_response_raw.v0"), + ), + ( + rmpv::Value::from("messageId"), + rmpv::Value::from(message_id.as_str()), + ), + ( + rmpv::Value::from("documents"), + rmpv::Value::Array(documents.iter().map(encode_raw_document_record).collect()), + ), + ], + _ => { + return Err(anyhow!( + "Message is not a raw cultnet.schema.v0 binary replication message" + )); + } + })) +} + +fn require_raw_document_record( + value: Option<&rmpv::Value>, + field_name: &str, +) -> Result { + let object = value + .and_then(rmpv::Value::as_map) + .ok_or_else(|| anyhow!("{field_name} must be an object"))?; + + let get = |name: &str| -> Option<&rmpv::Value> { + object.iter().find_map(|(key, value)| { + key.as_str() + .filter(|candidate| *candidate == name) + .map(|_| value) + }) + }; + + let payload_encoding = require_legacy_string( + get("payloadEncoding"), + &format!("{field_name}.payloadEncoding"), + )?; + + Ok(CultNetRawDocumentRecord { + schema_id: require_legacy_string(get("schemaId"), &format!("{field_name}.schemaId"))?, + record_key: require_legacy_string(get("recordKey"), &format!("{field_name}.recordKey"))?, + stored_at: require_legacy_string(get("storedAt"), &format!("{field_name}.storedAt"))?, + payload_encoding: match payload_encoding.as_str() { + "messagepack" => CultNetRawPayloadEncoding::Messagepack, + _ => { + return Err(anyhow!( + "{field_name}.payloadEncoding has unsupported value {payload_encoding}" + )); + } + }, + payload: get("payload") + .and_then(rmpv::Value::as_slice) + .map(|bytes| bytes.to_vec()) + .ok_or_else(|| anyhow!("{field_name}.payload must be binary MessagePack bytes"))?, + source_runtime_id: require_legacy_optional_string( + get("sourceRuntimeId"), + &format!("{field_name}.sourceRuntimeId"), + )?, + source_agent_id: require_legacy_optional_string( + get("sourceAgentId"), + &format!("{field_name}.sourceAgentId"), + )?, + source_role: require_legacy_optional_string( + get("sourceRole"), + &format!("{field_name}.sourceRole"), + )?, + tags: require_legacy_optional_string_array(get("tags"), &format!("{field_name}.tags"))?, + }) +} + +fn encode_raw_document_record(document: &CultNetRawDocumentRecord) -> rmpv::Value { + rmpv::Value::Map(vec![ + ( + rmpv::Value::from("schemaId"), + rmpv::Value::from(document.schema_id.as_str()), + ), + ( + rmpv::Value::from("recordKey"), + rmpv::Value::from(document.record_key.as_str()), + ), + ( + rmpv::Value::from("storedAt"), + rmpv::Value::from(document.stored_at.as_str()), + ), + ( + rmpv::Value::from("payloadEncoding"), + rmpv::Value::from(match document.payload_encoding { + CultNetRawPayloadEncoding::Messagepack => "messagepack", + }), + ), + ( + rmpv::Value::from("payload"), + rmpv::Value::Binary(document.payload.clone()), + ), + ( + rmpv::Value::from("sourceRuntimeId"), + document + .source_runtime_id + .as_deref() + .map(rmpv::Value::from) + .unwrap_or(rmpv::Value::Nil), + ), + ( + rmpv::Value::from("sourceAgentId"), + document + .source_agent_id + .as_deref() + .map(rmpv::Value::from) + .unwrap_or(rmpv::Value::Nil), + ), + ( + rmpv::Value::from("sourceRole"), + document + .source_role + .as_deref() + .map(rmpv::Value::from) + .unwrap_or(rmpv::Value::Nil), + ), + ( + rmpv::Value::from("tags"), + legacy_optional_string_array(document.tags.as_deref()), + ), + ]) +} + +fn parse_gamecult_networking_message(input: &rmpv::Value) -> Result { + let items = input.as_array().ok_or_else(|| { + anyhow!("gamecult.networking.v0 messages must be a 2-element union array") + })?; + if items.len() != 2 { + return Err(anyhow!( + "gamecult.networking.v0 messages must be a 2-element union array" + )); + } + let tag = items[0] + .as_i64() + .ok_or_else(|| anyhow!("gamecult.networking.v0 message tag must be an integer"))?; + let payload = items[1] + .as_array() + .ok_or_else(|| anyhow!("gamecult.networking.v0 message payload must be an array"))?; + match tag { + 0 => Ok(CultNetMessage::Login { + nonce: require_legacy_bytes(payload.first(), "LoginMessage.Nonce")?, + auth: require_legacy_bytes(payload.get(1), "LoginMessage.Auth")?, + password: require_legacy_bytes(payload.get(2), "LoginMessage.Password")?, + }), + 1 => Ok(CultNetMessage::Register { + nonce: require_legacy_bytes(payload.first(), "RegisterMessage.Nonce")?, + email: require_legacy_bytes(payload.get(1), "RegisterMessage.Email")?, + password: require_legacy_bytes(payload.get(2), "RegisterMessage.Password")?, + name: require_legacy_bytes(payload.get(3), "RegisterMessage.Name")?, + }), + 2 => Ok(CultNetMessage::Verify { + nonce: require_legacy_bytes(payload.first(), "VerifyMessage.Nonce")?, + session: require_legacy_bytes(payload.get(1), "VerifyMessage.Session")?, + }), + 3 => Ok(CultNetMessage::LoginSuccess { + nonce: require_legacy_bytes(payload.first(), "LoginSuccessMessage.Nonce")?, + session: require_legacy_bytes(payload.get(1), "LoginSuccessMessage.Session")?, + }), + 4 => Ok(CultNetMessage::Error { + error: require_legacy_string(payload.first(), "ErrorMessage.Error")?, + }), + 5 => Ok(CultNetMessage::SampleChangeName { + name: require_legacy_string(payload.first(), "ChangeNameMessage.Name")?, + }), + 6 => Ok(CultNetMessage::SampleChat { + text: require_legacy_string(payload.first(), "ChatMessage.Text")?, + }), + 7 => Ok(CultNetMessage::SchemaCatalogRequest { + message_id: require_legacy_string( + payload.first(), + "SchemaCatalogRequestMessage.MessageId", + )?, + include_schema_json: Some(require_legacy_bool( + payload.get(1), + "SchemaCatalogRequestMessage.IncludeSchemaJson", + )?), + schema_ids: require_legacy_optional_string_array( + payload.get(2), + "SchemaCatalogRequestMessage.SchemaIds", + )?, + kinds: require_legacy_optional_schema_kind_array( + payload.get(3), + "SchemaCatalogRequestMessage.Kinds", + )?, + }), + 8 => Ok(CultNetMessage::SchemaCatalogResponse { + message_id: require_legacy_string( + payload.first(), + "SchemaCatalogResponseMessage.MessageId", + )?, + schemas: require_legacy_schema_descriptor_array( + payload.get(1), + "SchemaCatalogResponseMessage.Schemas", + )?, + }), + _ => Err(anyhow!( + "Unsupported gamecult.networking.v0 union tag {tag}" + )), + } +} + +fn encode_gamecult_networking_message(message: &CultNetMessage) -> Result { + let pair = match message { + CultNetMessage::Login { + nonce, + auth, + password, + } => vec![ + rmpv::Value::from(0), + rmpv::Value::Array(vec![ + legacy_bytes(nonce, "LoginMessage.Nonce")?, + legacy_bytes(auth, "LoginMessage.Auth")?, + legacy_bytes(password, "LoginMessage.Password")?, + ]), + ], + CultNetMessage::Register { + nonce, + email, + password, + name, + } => vec![ + rmpv::Value::from(1), + rmpv::Value::Array(vec![ + legacy_bytes(nonce, "RegisterMessage.Nonce")?, + legacy_bytes(email, "RegisterMessage.Email")?, + legacy_bytes(password, "RegisterMessage.Password")?, + legacy_bytes(name, "RegisterMessage.Name")?, + ]), + ], + CultNetMessage::Verify { nonce, session } => vec![ + rmpv::Value::from(2), + rmpv::Value::Array(vec![ + legacy_bytes(nonce, "VerifyMessage.Nonce")?, + legacy_bytes(session, "VerifyMessage.Session")?, + ]), + ], + CultNetMessage::LoginSuccess { nonce, session } => vec![ + rmpv::Value::from(3), + rmpv::Value::Array(vec![ + legacy_bytes(nonce, "LoginSuccessMessage.Nonce")?, + legacy_bytes(session, "LoginSuccessMessage.Session")?, + ]), + ], + CultNetMessage::Error { error } => { + vec![ + rmpv::Value::from(4), + rmpv::Value::Array(vec![error.as_str().into()]), + ] + } + CultNetMessage::SampleChangeName { name } => { + vec![ + rmpv::Value::from(5), + rmpv::Value::Array(vec![name.as_str().into()]), + ] + } + CultNetMessage::SampleChat { text } => { + vec![ + rmpv::Value::from(6), + rmpv::Value::Array(vec![text.as_str().into()]), + ] + } + CultNetMessage::SchemaCatalogRequest { + message_id, + include_schema_json, + schema_ids, + kinds, + } => vec![ + rmpv::Value::from(7), + rmpv::Value::Array(vec![ + message_id.as_str().into(), + rmpv::Value::from(include_schema_json.unwrap_or(false)), + legacy_optional_string_array(schema_ids.as_deref()), + legacy_optional_schema_kind_array(kinds.as_deref()), + ]), + ], + CultNetMessage::SchemaCatalogResponse { + message_id, + schemas, + } => vec![ + rmpv::Value::from(8), + rmpv::Value::Array(vec![ + message_id.as_str().into(), + rmpv::Value::Array( + schemas + .iter() + .map(legacy_schema_descriptor) + .collect::>>()?, + ), + ]), + ], + _ => { + return Err(anyhow!( + "Message is not defined in the gamecult.networking.v0 contract" + )); + } + }; + Ok(rmpv::Value::Array(pair)) +} + +fn require_legacy_bytes(value: Option<&rmpv::Value>, field_name: &str) -> Result { + let bytes = value + .and_then(rmpv::Value::as_slice) + .ok_or_else(|| anyhow!("{field_name} must be binary data in gamecult.networking.v0"))?; + Ok(URL_SAFE_NO_PAD.encode(bytes)) +} + +fn require_legacy_string(value: Option<&rmpv::Value>, field_name: &str) -> Result { + let value = value + .and_then(rmpv::Value::as_str) + .ok_or_else(|| anyhow!("{field_name} must be a string in gamecult.networking.v0"))?; + Ok(value.to_string()) +} + +fn require_legacy_bool(value: Option<&rmpv::Value>, field_name: &str) -> Result { + value + .and_then(rmpv::Value::as_bool) + .ok_or_else(|| anyhow!("{field_name} must be a boolean in gamecult.networking.v0")) +} + +fn require_legacy_optional_string_array( + value: Option<&rmpv::Value>, + field_name: &str, +) -> Result>> { + let Some(value) = value else { + return Ok(None); + }; + if value.is_nil() { + return Ok(None); + } + let items = value + .as_array() + .ok_or_else(|| anyhow!("{field_name} must be an array in gamecult.networking.v0"))?; + let values = items + .iter() + .map(|item| { + item.as_str() + .map(ToString::to_string) + .ok_or_else(|| anyhow!("{field_name} must contain only strings")) + }) + .collect::>>()?; + Ok(Some(values)) +} + +fn require_legacy_optional_schema_kind_array( + value: Option<&rmpv::Value>, + field_name: &str, +) -> Result>> { + let Some(values) = require_legacy_optional_string_array(value, field_name)? else { + return Ok(None); + }; + values + .into_iter() + .map(|value| match value.as_str() { + "wire_message" => Ok(CultNetSchemaKind::WireMessage), + "document_payload" => Ok(CultNetSchemaKind::DocumentPayload), + "shared_contract" => Ok(CultNetSchemaKind::SharedContract), + _ => Err(anyhow!("{field_name} has unsupported schema kind {value}")), + }) + .collect::>>() + .map(Some) +} + +fn require_legacy_schema_descriptor_array( + value: Option<&rmpv::Value>, + field_name: &str, +) -> Result> { + let items = value + .and_then(rmpv::Value::as_array) + .ok_or_else(|| anyhow!("{field_name} must be an array in gamecult.networking.v0"))?; + items + .iter() + .enumerate() + .map(|(index, item)| { + require_legacy_schema_descriptor(item, &format!("{field_name}[{index}]")) + }) + .collect() +} + +fn require_legacy_schema_descriptor( + value: &rmpv::Value, + field_name: &str, +) -> Result { + let object = value + .as_map() + .ok_or_else(|| anyhow!("{field_name} must be an object in gamecult.networking.v0"))?; + + let get = |name: &str| -> Option<&rmpv::Value> { + object.iter().find_map(|(key, value)| { + key.as_str() + .filter(|candidate| *candidate == name) + .map(|_| value) + }) + }; + + let schema_id = require_legacy_string(get("schemaId"), &format!("{field_name}.SchemaId"))?; + let kind = require_legacy_string(get("kind"), &format!("{field_name}.Kind"))?; + let schema_version = require_legacy_optional_string( + get("schemaVersion"), + &format!("{field_name}.SchemaVersion"), + )?; + let document_type = + require_legacy_optional_string(get("documentType"), &format!("{field_name}.DocumentType"))?; + let title = require_legacy_optional_string(get("title"), &format!("{field_name}.Title"))?; + let wire_contracts = require_legacy_optional_wire_contracts( + get("wireContracts"), + &format!("{field_name}.WireContracts"), + )?; + let content_hash = + require_legacy_string(get("contentHash"), &format!("{field_name}.ContentHash"))?; + let schema_json = + require_legacy_optional_string(get("schemaJson"), &format!("{field_name}.SchemaJson"))?; + + let kind = match kind.as_str() { + "wire_message" => CultNetSchemaKind::WireMessage, + "document_payload" => CultNetSchemaKind::DocumentPayload, + "shared_contract" => CultNetSchemaKind::SharedContract, + _ => { + return Err(anyhow!( + "{field_name}.Kind has unsupported schema kind {kind}" + )); + } + }; + + Ok(CultNetSchemaDescriptor { + schema_id, + kind, + schema_version, + document_type, + title, + wire_contracts, + content_hash, + schema_json, + }) +} + +fn require_legacy_optional_string( + value: Option<&rmpv::Value>, + field_name: &str, +) -> Result> { + let Some(value) = value else { + return Ok(None); + }; + if value.is_nil() { + return Ok(None); + } + Ok(Some(require_legacy_string(Some(value), field_name)?)) +} + +fn require_legacy_optional_wire_contracts( + value: Option<&rmpv::Value>, + field_name: &str, +) -> Result> { + let Some(values) = require_legacy_optional_string_array(value, field_name)? else { + return Ok(Vec::new()); + }; + + values + .into_iter() + .map(|value| match value.as_str() { + "cultnet.schema.v0" => Ok(CultNetWireContract::CultNetSchemaV0), + "gamecult.networking.v0" => Ok(CultNetWireContract::GameCultNetworkingV0), + _ => Err(anyhow!( + "{field_name} contains unsupported wire contract {value}" + )), + }) + .collect() +} + +fn legacy_bytes(input: &str, field_name: &str) -> Result { + if input.trim().is_empty() { + return Err(anyhow!("{field_name} must be a non-empty base64url string")); + } + Ok(rmpv::Value::Binary(URL_SAFE_NO_PAD.decode(input)?)) +} + +fn legacy_optional_string_array(input: Option<&[String]>) -> rmpv::Value { + match input { + Some(values) => rmpv::Value::Array( + values + .iter() + .map(|value| rmpv::Value::from(value.as_str())) + .collect(), + ), + None => rmpv::Value::Nil, + } +} + +fn legacy_optional_schema_kind_array(input: Option<&[CultNetSchemaKind]>) -> rmpv::Value { + match input { + Some(values) => rmpv::Value::Array( + values + .iter() + .map(|value| { + rmpv::Value::from(match value { + CultNetSchemaKind::WireMessage => "wire_message", + CultNetSchemaKind::DocumentPayload => "document_payload", + CultNetSchemaKind::SharedContract => "shared_contract", + }) + }) + .collect(), + ), + None => rmpv::Value::Nil, + } +} + +fn legacy_schema_descriptor(schema: &CultNetSchemaDescriptor) -> Result { + Ok(rmpv::Value::Map(vec![ + ( + rmpv::Value::from("schemaId"), + rmpv::Value::from(schema.schema_id.as_str()), + ), + ( + rmpv::Value::from("kind"), + rmpv::Value::from(match schema.kind { + CultNetSchemaKind::WireMessage => "wire_message", + CultNetSchemaKind::DocumentPayload => "document_payload", + CultNetSchemaKind::SharedContract => "shared_contract", + }), + ), + ( + rmpv::Value::from("schemaVersion"), + schema + .schema_version + .as_deref() + .map(rmpv::Value::from) + .unwrap_or(rmpv::Value::Nil), + ), + ( + rmpv::Value::from("documentType"), + schema + .document_type + .as_deref() + .map(rmpv::Value::from) + .unwrap_or(rmpv::Value::Nil), + ), + ( + rmpv::Value::from("title"), + schema + .title + .as_deref() + .map(rmpv::Value::from) + .unwrap_or(rmpv::Value::Nil), + ), + ( + rmpv::Value::from("wireContracts"), + rmpv::Value::Array( + schema + .wire_contracts + .iter() + .map(|value| { + rmpv::Value::from(match value { + CultNetWireContract::CultNetSchemaV0 => "cultnet.schema.v0", + CultNetWireContract::GameCultNetworkingV0 => "gamecult.networking.v0", + }) + }) + .collect(), + ), + ), + ( + rmpv::Value::from("contentHash"), + rmpv::Value::from(schema.content_hash.as_str()), + ), + ( + rmpv::Value::from("schemaJson"), + schema + .schema_json + .as_deref() + .map(rmpv::Value::from) + .unwrap_or(rmpv::Value::Nil), + ), + ])) +} diff --git a/vendor/cultnet-rs/src/framing.rs b/vendor/cultnet-rs/src/framing.rs new file mode 100644 index 0000000..0157881 --- /dev/null +++ b/vendor/cultnet-rs/src/framing.rs @@ -0,0 +1,49 @@ +use anyhow::Result; +use anyhow::anyhow; + +pub const FRAME_HEADER_BYTES: usize = 4; + +pub fn encode_frame(payload: &[u8]) -> Result> { + let len: u32 = payload + .len() + .try_into() + .map_err(|_| anyhow!("CultNet frame payload is too large"))?; + let mut frame = Vec::with_capacity(FRAME_HEADER_BYTES + payload.len()); + frame.extend_from_slice(&len.to_be_bytes()); + frame.extend_from_slice(payload); + Ok(frame) +} + +#[derive(Clone, Debug, Default)] +pub struct LengthPrefixedMessageFramer { + buffer: Vec, +} + +impl LengthPrefixedMessageFramer { + pub fn new() -> Self { + Self::default() + } + + pub fn push(&mut self, chunk: impl AsRef<[u8]>) -> Vec> { + self.buffer.extend_from_slice(chunk.as_ref()); + let mut frames = Vec::new(); + loop { + if self.buffer.len() < FRAME_HEADER_BYTES { + break; + } + let payload_len = u32::from_be_bytes([ + self.buffer[0], + self.buffer[1], + self.buffer[2], + self.buffer[3], + ]) as usize; + let total_len = FRAME_HEADER_BYTES + payload_len; + if self.buffer.len() < total_len { + break; + } + frames.push(self.buffer[FRAME_HEADER_BYTES..total_len].to_vec()); + self.buffer.drain(0..total_len); + } + frames + } +} diff --git a/vendor/cultnet-rs/src/lib.rs b/vendor/cultnet-rs/src/lib.rs new file mode 100644 index 0000000..bc804d3 --- /dev/null +++ b/vendor/cultnet-rs/src/lib.rs @@ -0,0 +1,15 @@ +mod contracts; +mod framing; +mod replication; +mod rudp; +mod schema_discovery; +mod security; +mod transport; + +pub use contracts::*; +pub use framing::*; +pub use replication::*; +pub use rudp::*; +pub use schema_discovery::*; +pub use security::*; +pub use transport::*; diff --git a/vendor/cultnet-rs/src/replication.rs b/vendor/cultnet-rs/src/replication.rs new file mode 100644 index 0000000..492cf31 --- /dev/null +++ b/vendor/cultnet-rs/src/replication.rs @@ -0,0 +1,440 @@ +use anyhow::Context; +use anyhow::Result; +use anyhow::anyhow; +use cultcache_rs::CultCache; +use cultcache_rs::CultCacheEnvelope; +use cultcache_rs::DatabaseEntry; +use serde::Serialize; +use serde::de::DeserializeOwned; +use serde_json::Value; +use std::collections::BTreeMap; +use std::collections::BTreeSet; + +use crate::CultNetDocumentMutationContract; +use crate::CultNetDocumentRecord; +use crate::CultNetMessage; +use crate::CultNetRawDocumentRecord; +use crate::CultNetRawPayloadEncoding; + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct CultNetDocumentPutOptions { + pub stored_at: Option, + pub source_runtime_id: Option, + pub source_agent_id: Option, + pub source_role: Option, + pub tags: Option>, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultNetDocumentBinding { + pub schema_id: String, + pub document_type: String, + pub mutation_contract: Option, + pub payload_schema_version: Option, +} + +impl CultNetDocumentBinding { + pub fn for_entry(payload_schema_version: impl Into>) -> Self { + Self { + document_type: T::TYPE.to_string(), + schema_id: T::TYPE.to_string(), + mutation_contract: None, + payload_schema_version: payload_schema_version.into(), + } + } + + pub fn for_entry_with_schema_id( + schema_id: impl Into, + payload_schema_version: impl Into>, + ) -> Self { + Self { + document_type: T::TYPE.to_string(), + schema_id: schema_id.into(), + mutation_contract: None, + payload_schema_version: payload_schema_version.into(), + } + } + + pub fn with_mutation_contract(mut self, contract: CultNetDocumentMutationContract) -> Self { + self.mutation_contract = Some(contract); + self + } +} + +#[derive(Clone, Debug, Default)] +pub struct CultNetDocumentRegistry { + bindings_by_type: BTreeMap, + bindings_by_schema_id: BTreeMap, +} + +impl CultNetDocumentRegistry { + pub fn new() -> Self { + Self::default() + } + + pub fn register(&mut self, binding: CultNetDocumentBinding) -> &mut Self { + self.bindings_by_schema_id + .insert(binding.schema_id.clone(), binding.clone()); + self.bindings_by_type + .insert(binding.document_type.clone(), binding); + self + } + + pub fn binding(&self, document_type: &str) -> Option<&CultNetDocumentBinding> { + self.bindings_by_type.get(document_type) + } + + pub fn binding_by_schema_id(&self, schema_id: &str) -> Option<&CultNetDocumentBinding> { + self.bindings_by_schema_id.get(schema_id) + } + + pub fn mutation_contracts(&self) -> Vec { + self.bindings_by_type + .values() + .filter_map(|binding| binding.mutation_contract.clone()) + .collect() + } + + pub fn create_document_put_message( + &self, + message_id: impl Into, + record_key: impl Into, + value: &T, + options: CultNetDocumentPutOptions, + ) -> Result + where + T: DatabaseEntry + Serialize + DeserializeOwned, + { + let binding = self.require_binding(T::TYPE)?; + let payload = serde_json::to_value(round_trip_typed(value)?)?; + Ok(CultNetMessage::DocumentPut { + message_id: message_id.into(), + document: CultNetDocumentRecord { + schema_id: binding.schema_id.clone(), + record_key: record_key.into(), + stored_at: options.stored_at.unwrap_or_else(now_utc_second), + payload, + source_runtime_id: options.source_runtime_id, + source_agent_id: options.source_agent_id, + source_role: options.source_role, + tags: options.tags, + }, + }) + } + + pub fn create_document_delete_message( + &self, + message_id: impl Into, + schema_id: impl Into, + record_key: impl Into, + ) -> CultNetMessage { + CultNetMessage::DocumentDelete { + message_id: message_id.into(), + schema_id: schema_id.into(), + record_key: record_key.into(), + } + } + + pub fn create_raw_document_put_message_from_envelope( + &self, + message_id: impl Into, + envelope: &CultCacheEnvelope, + ) -> Result { + Ok(CultNetMessage::DocumentPutRaw { + message_id: message_id.into(), + document: self.raw_document_record_from_envelope(envelope)?, + }) + } + + pub fn create_raw_document_put_message( + &self, + message_id: impl Into, + record_key: impl Into, + value: &T, + options: CultNetDocumentPutOptions, + ) -> Result + where + T: DatabaseEntry + Serialize, + { + let binding = self.require_binding(T::TYPE)?; + Ok(CultNetMessage::DocumentPutRaw { + message_id: message_id.into(), + document: CultNetRawDocumentRecord { + schema_id: binding.schema_id.clone(), + record_key: record_key.into(), + stored_at: options.stored_at.unwrap_or_else(now_utc_second), + payload_encoding: CultNetRawPayloadEncoding::Messagepack, + payload: rmp_serde::to_vec(value)?, + source_runtime_id: options.source_runtime_id, + source_agent_id: options.source_agent_id, + source_role: options.source_role, + tags: options.tags, + }, + }) + } + + pub fn create_snapshot_response( + &self, + cache: &CultCache, + message_id: impl Into, + schema_ids: Option<&[String]>, + record_keys: Option<&[String]>, + ) -> Result { + let requested_schema_ids = schema_ids.map(|items| items.iter().collect::>()); + let requested_record_keys = record_keys.map(|items| items.iter().collect::>()); + let mut documents = Vec::new(); + for envelope in cache.snapshot() { + let binding = self.require_binding(&envelope.r#type)?; + if requested_schema_ids + .as_ref() + .is_some_and(|ids| !ids.contains(&binding.schema_id)) + { + continue; + } + if requested_record_keys + .as_ref() + .is_some_and(|keys| !keys.contains(&envelope.key)) + { + continue; + } + documents.push(self.document_record_from_envelope(&envelope)?); + } + Ok(CultNetMessage::SnapshotResponse { + message_id: message_id.into(), + documents, + }) + } + + pub fn create_raw_snapshot_response( + &self, + cache: &CultCache, + message_id: impl Into, + schema_ids: Option<&[String]>, + record_keys: Option<&[String]>, + ) -> Result { + let requested_schema_ids = schema_ids.map(|items| items.iter().collect::>()); + let requested_record_keys = record_keys.map(|items| items.iter().collect::>()); + let mut documents = Vec::new(); + for envelope in cache.snapshot() { + let binding = self.require_binding(&envelope.r#type)?; + if requested_schema_ids + .as_ref() + .is_some_and(|ids| !ids.contains(&binding.schema_id)) + { + continue; + } + if requested_record_keys + .as_ref() + .is_some_and(|keys| !keys.contains(&envelope.key)) + { + continue; + } + documents.push(self.raw_document_record_from_envelope(&envelope)?); + } + Ok(CultNetMessage::SnapshotResponseRaw { + message_id: message_id.into(), + documents, + }) + } + + pub fn apply_document_put_message( + &self, + cache: &mut CultCache, + message: &CultNetMessage, + ) -> Result + where + T: DatabaseEntry + Serialize + DeserializeOwned, + { + let CultNetMessage::DocumentPut { document, .. } = message else { + return Err(anyhow!("expected cultnet.document_put.v0")); + }; + let binding = self.require_binding(T::TYPE)?; + if document.schema_id != binding.schema_id { + return Err(anyhow!( + "schema id {:?} does not match registered Rust type {:?} schema {:?}", + document.schema_id, + T::TYPE, + binding.schema_id + )); + } + let value: T = serde_json::from_value(document.payload.clone()).with_context(|| { + format!( + "failed to decode CultNet payload schema {:?} as {}", + binding.schema_id, + T::SCHEMA_NAME + ) + })?; + cache.put(&document.record_key, &value) + } + + pub fn apply_document_delete_message( + &self, + cache: &mut CultCache, + message: &CultNetMessage, + ) -> Result + where + T: DatabaseEntry, + { + let CultNetMessage::DocumentDelete { + schema_id, + record_key, + .. + } = message + else { + return Err(anyhow!("expected cultnet.document_delete.v0")); + }; + let binding = self.require_binding(T::TYPE)?; + if schema_id != &binding.schema_id { + return Err(anyhow!( + "schema id {:?} does not match registered Rust type {:?} schema {:?}", + schema_id, + T::TYPE, + binding.schema_id + )); + } + cache.delete::(record_key) + } + + pub fn apply_raw_document_put_message( + &self, + cache: &mut CultCache, + message: &CultNetMessage, + ) -> Result + where + T: DatabaseEntry + Serialize + DeserializeOwned, + { + let CultNetMessage::DocumentPutRaw { document, .. } = message else { + return Err(anyhow!("expected cultnet.document_put_raw.v0")); + }; + let binding = self.require_binding(T::TYPE)?; + if document.schema_id != binding.schema_id { + return Err(anyhow!( + "schema id {:?} does not match registered Rust type {:?} schema {:?}", + document.schema_id, + T::TYPE, + binding.schema_id + )); + } + cache.put_envelope::(CultCacheEnvelope { + key: document.record_key.clone(), + r#type: binding.document_type.clone(), + payload: document.payload.clone(), + stored_at: document.stored_at.clone(), + schema_id: Some(binding.schema_id.clone()), + }) + } + + pub fn apply_snapshot_response( + &self, + cache: &mut CultCache, + response: &CultNetMessage, + ) -> Result> + where + T: DatabaseEntry + Serialize + DeserializeOwned, + { + let CultNetMessage::SnapshotResponse { documents, .. } = response else { + return Err(anyhow!("expected cultnet.snapshot_response.v0")); + }; + let mut applied = Vec::new(); + let binding = self.require_binding(T::TYPE)?; + for document in documents { + if document.schema_id != binding.schema_id { + continue; + } + applied.push(self.apply_document_put_message::( + cache, + &CultNetMessage::DocumentPut { + message_id: "snapshot-apply".to_string(), + document: document.clone(), + }, + )?); + } + Ok(applied) + } + + pub fn apply_raw_snapshot_response( + &self, + cache: &mut CultCache, + response: &CultNetMessage, + ) -> Result> + where + T: DatabaseEntry + Serialize + DeserializeOwned, + { + let CultNetMessage::SnapshotResponseRaw { documents, .. } = response else { + return Err(anyhow!("expected cultnet.snapshot_response_raw.v0")); + }; + let mut applied = Vec::new(); + let binding = self.require_binding(T::TYPE)?; + for document in documents { + if document.schema_id != binding.schema_id { + continue; + } + applied.push(self.apply_raw_document_put_message::( + cache, + &CultNetMessage::DocumentPutRaw { + message_id: "snapshot-apply-raw".to_string(), + document: document.clone(), + }, + )?); + } + Ok(applied) + } + + fn document_record_from_envelope( + &self, + envelope: &CultCacheEnvelope, + ) -> Result> { + let binding = self.require_binding(&envelope.r#type)?; + let payload: Value = rmp_serde::from_slice(&envelope.payload).with_context(|| { + format!( + "failed to decode CultCache envelope {:?} at {:?} as generic CultNet payload", + envelope.r#type, envelope.key + ) + })?; + Ok(CultNetDocumentRecord { + schema_id: binding.schema_id.clone(), + record_key: envelope.key.clone(), + stored_at: envelope.stored_at.clone(), + payload, + source_runtime_id: None, + source_agent_id: None, + source_role: None, + tags: None, + }) + } + + fn raw_document_record_from_envelope( + &self, + envelope: &CultCacheEnvelope, + ) -> Result { + let binding = self.require_binding(&envelope.r#type)?; + Ok(CultNetRawDocumentRecord { + schema_id: binding.schema_id.clone(), + record_key: envelope.key.clone(), + stored_at: envelope.stored_at.clone(), + payload_encoding: CultNetRawPayloadEncoding::Messagepack, + payload: envelope.payload.clone(), + source_runtime_id: None, + source_agent_id: None, + source_role: None, + tags: None, + }) + } + + fn require_binding(&self, document_type: &str) -> Result<&CultNetDocumentBinding> { + self.binding(document_type).ok_or_else(|| { + anyhow!("No CultNet document binding is registered for {document_type:?}") + }) + } +} + +fn round_trip_typed(value: &T) -> Result +where + T: Serialize + DeserializeOwned, +{ + Ok(rmp_serde::from_slice(&rmp_serde::to_vec(value)?)?) +} + +fn now_utc_second() -> String { + chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Secs, true) +} diff --git a/vendor/cultnet-rs/src/rudp.rs b/vendor/cultnet-rs/src/rudp.rs new file mode 100644 index 0000000..50972b5 --- /dev/null +++ b/vendor/cultnet-rs/src/rudp.rs @@ -0,0 +1,1444 @@ +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; +use std::net::UdpSocket; +use std::thread; +use std::time::Duration; +use std::time::SystemTime; +use std::time::UNIX_EPOCH; + +use crate::CultNetTransportChannel; +use crate::CultNetTransportDelivery; +use crate::CultNetTransportDescriptor; +use crate::CultNetTransportFrame; +use crate::CultNetTransportOrdering; +use crate::CultNetTransportProfile; +use crate::CultNetTransportProtocol; +use crate::CultNetTransportStats; + +const RUDP_MAGIC: [u8; 4] = [0x43, 0x4e, 0x52, 0x30]; +const RUDP_VERSION: u8 = 0; +const RUDP_FIXED_HEADER_BYTES: usize = 36; +const DEFAULT_MEDIA_RELIABLE_EXPIRE_AFTER_MS: u64 = 75; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CultNetRudpPacketType { + Connect, + Accept, + Data, + Ack, + Ping, + Pong, + Disconnect, +} + +#[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 { + connection_id: 0, + initial_sequence: 1, + resend_delay_ms: 250, + max_pending_reliable_packets: None, + } + } +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct CultNetRudpSendOptions { + pub reliable: bool, + pub ordered: bool, + pub sequenced: bool, + pub now_ms: u64, + pub reliable_expire_after_ms: Option, +} + +#[derive(Clone, Debug, PartialEq, Eq)] +struct PendingReliablePacket { + packet: CultNetRudpPacket, + last_sent_at_ms: u64, + expires_at_ms: Option, +} + +#[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>, + highest_delivered_sequenced_by_channel: BTreeMap, + reliable_packets_expired: u64, +} + +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(), + highest_delivered_sequenced_by_channel: BTreeMap::new(), + reliable_packets_expired: 0, + } + } + + 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 reset_peer_state(&mut self) { + self.connected = false; + self.last_received_at_ms = None; + self.highest_received_sequence = None; + self.received_sequences.clear(); + self.pending_reliable.clear(); + self.ordered_next_sequence_by_channel.clear(); + self.ordered_buffers.clear(); + self.fragment_buffers.clear(); + self.highest_delivered_sequenced_by_channel.clear(); + } + + pub fn assume_connected(&mut self, now_ms: u64) { + self.connected = true; + self.last_received_at_ms = Some(now_ms); + } + + 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 reliable_packets_expired(&self) -> u64 { + self.reliable_packets_expired + } + + 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( + &CultNetRudpSendOptions { + reliable: true, + ordered: true, + sequenced: false, + now_ms, + reliable_expire_after_ms: None, + }, + packet.clone(), + ); + Ok(packet) + } + + pub fn accept_connect( + &mut self, + packet: &CultNetRudpPacket, + now_ms: u64, + payload: Vec, + ) -> Result { + self.require_connection(packet)?; + if packet.packet_type != CultNetRudpPacketType::Connect { + return Err(anyhow!( + "Expected RUDP connect packet, got {:?}", + packet.packet_type + )); + } + + let was_connected = self.connected; + if !was_connected { + self.ensure_reliable_capacity(1)?; + } + self.remember_received(packet.sequence); + self.last_received_at_ms = Some(now_ms); + self.connected = true; + let response = self.create_packet( + CultNetRudpPacketType::Accept, + "control", + payload, + true, + true, + false, + ); + if !was_connected { + self.track_reliable( + &CultNetRudpSendOptions { + reliable: true, + ordered: true, + sequenced: false, + now_ms, + reliable_expire_after_ms: None, + }, + response.clone(), + ); + } + Ok(response) + } + + 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" + )); + } + self.purge_expired_reliable(options.now_ms); + + 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(&options, packet.clone()); + } + 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(&options, packet.clone()); + } + 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(), + }); + }; + if packet.sequenced && !ordered { + let highest = self + .highest_delivered_sequenced_by_channel + .entry(frame.channel_id.clone()) + .or_insert(frame.sequence); + if frame.sequence < *highest { + return Ok(CultNetRudpReceiveResult { + delivered: Vec::new(), + reply: None, + pong: false, + pong_payload: Vec::new(), + disconnected: false, + disconnect_reason: Vec::new(), + }); + } + *highest = frame.sequence; + } + 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 { + self.purge_expired_reliable(now_ms); + 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, options: &CultNetRudpSendOptions, packet: CultNetRudpPacket) { + let expires_at_ms = options + .reliable_expire_after_ms + .map(|ttl| options.now_ms.saturating_add(ttl)); + self.pending_reliable.insert( + packet.sequence, + PendingReliablePacket { + packet, + last_sent_at_ms: options.now_ms, + expires_at_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 purge_expired_reliable(&mut self, now_ms: u64) { + let before = self.pending_reliable.len(); + self.pending_reliable.retain(|_, pending| { + pending + .expires_at_ms + .map_or(true, |expires_at_ms| now_ms <= expires_at_ms) + }); + self.reliable_packets_expired += (before - self.pending_reliable.len()) as u64; + } + + 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)); + } + } + } + + 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); + } + } + + 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(()) + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum CultNetRudpSocketMode { + Client, + Server, +} + +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, + pub media_reliable_expire_after_ms: 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, + media_reliable_expire_after_ms: Some(DEFAULT_MEDIA_RELIABLE_EXPIRE_AFTER_MS), + } + } + + 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, + media_reliable_expire_after_ms: Some(DEFAULT_MEDIA_RELIABLE_EXPIRE_AFTER_MS), + } + } +} + +pub struct CultNetRudpSocketTransportConnection { + socket: UdpSocket, + session: CultNetRudpSession, + mode: CultNetRudpSocketMode, + remote_addr: Option, + pub profile: CultNetTransportProfile, + transport_id: Option, + 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 transport_id = options.transport_id.clone(); + 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, + media_reliable_expire_after_ms: options.media_reliable_expire_after_ms, + }, + ); + 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, + transport_id, + 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 assume_connected(&mut self) { + self.session.assume_connected(now_ms()); + } + + pub fn stats(&self) -> CultNetTransportStats { + let mut stats = self.stats.clone(); + stats.reliable_packets_expired = self.session.reliable_packets_expired(); + stats + } + + 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 = self.channel_send_options(channel_id, now_ms()); + let packets = + self.session + .send_many(channel_id, payload, options, self.max_fragment_bytes)?; + let fragmented = packets.len() > 1; + for (index, packet) in packets.iter().enumerate() { + self.send_packet(packet)?; + if fragmented && (index + 1) % 16 == 0 { + thread::sleep(Duration::from_millis(1)); + } + } + 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) + } + + fn channel_send_options(&self, channel_id: &str, now_ms: u64) -> CultNetRudpSendOptions { + match channel_id { + "schema" => CultNetRudpSendOptions { + reliable: true, + ordered: true, + sequenced: false, + now_ms, + reliable_expire_after_ms: None, + }, + "latest" => CultNetRudpSendOptions { + reliable: false, + ordered: false, + sequenced: true, + now_ms, + reliable_expire_after_ms: None, + }, + "media" => CultNetRudpSendOptions { + reliable: false, + ordered: false, + sequenced: false, + now_ms, + reliable_expire_after_ms: None, + }, + _ => CultNetRudpSendOptions { + reliable: false, + ordered: false, + sequenced: false, + now_ms, + reliable_expire_after_ms: None, + }, + } + } + + pub fn receive_once(&mut self) -> Result> { + if let Some(frame) = self.delivered_frames.pop_front() { + self.session.assume_connected(now_ms()); + 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; + + let packet = match decode_rudp_packet(&wire) { + Ok(packet) => packet, + Err(error) => { + if std::env::var_os("CULTNET_RUDP_TRACE").is_some() + && self.transport_id.as_deref() == Some("muninn-provider-command-rudp") + { + eprintln!( + "RUDP muninn-provider-command-rudp rejected {} bytes from {remote_addr}: {error:#}", + wire.len() + ); + } + return Ok(None); + } + }; + let trace_transport = std::env::var_os("CULTNET_RUDP_TRACE").is_some() + && self.transport_id.as_deref().is_some_and(|id| { + id == "sleipnir-hid-rudp" + || id == "muninn-hid-controller-rudp" + || id == "muninn-provider-command-rudp" + }); + if trace_transport { + eprintln!( + "RUDP {} recv {:?} channel={} seq={} ack={} reliable={} ordered={} sequenced={} bytes={} from {}", + self.transport_id.as_deref().unwrap_or("unknown"), + packet.packet_type, + packet.channel_id, + packet.sequence, + packet.ack, + packet.reliable, + packet.ordered, + packet.sequenced, + packet.payload.len(), + remote_addr + ); + } + + if let Some(expected) = self.remote_addr { + if expected != remote_addr { + if self.mode == CultNetRudpSocketMode::Server + && packet.packet_type == CultNetRudpPacketType::Connect + { + self.remote_addr = Some(remote_addr); + } else { + return Ok(None); + } + } + } else { + if self.mode == CultNetRudpSocketMode::Server + && packet.packet_type != CultNetRudpPacketType::Connect + { + return Ok(None); + } + self.remote_addr = Some(remote_addr); + } + if self.mode == CultNetRudpSocketMode::Server + && packet.packet_type == CultNetRudpPacketType::Connect + { + self.session.reset_peer_state(); + 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 (index, packet) in self.session.due_resends(now_ms()).into_iter().enumerate() { + self.send_packet(&packet)?; + if (index + 1) % 16 == 0 { + thread::sleep(Duration::from_millis(1)); + } + } + 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 trace_transport = std::env::var_os("CULTNET_RUDP_TRACE").is_some() + && self + .transport_id + .as_deref() + .is_some_and(|id| id == "sleipnir-hid-rudp" || id == "muninn-hid-controller-rudp"); + if trace_transport { + eprintln!( + "RUDP {} send {:?} channel={} seq={} ack={} reliable={} ordered={} sequenced={} payload={} wire={} to {}", + self.transport_id.as_deref().unwrap_or("unknown"), + packet.packet_type, + packet.channel_id, + packet.sequence, + packet.ack, + packet.reliable, + packet.ordered, + packet.sequenced, + packet.payload.len(), + wire.len(), + remote_addr + ); + } + 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 media_reliable_expire_after_ms: 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, + reliable_expire_after_ms: None, + }, + 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, + reliable_expire_after_ms: None, + }, + 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, + reliable_expire_after_ms: None, + }, + CultNetTransportChannel { + channel_id: "media".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, + reliable_expire_after_ms: None, + }, + ], + }], + } +} + +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 channel id cannot exceed 255 UTF-8 bytes" + )); + } + + 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) +} + +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] + )); + } + + 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, + } +} + +fn now_ms() -> u64 { + SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|duration| duration.as_millis() as u64) + .unwrap_or(0) +} + +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}")), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn connected_session(initial_sequence: u32) -> CultNetRudpSession { + let mut session = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 0xCAFE_BABE, + initial_sequence, + resend_delay_ms: 5, + max_pending_reliable_packets: Some(64), + }); + session.assume_connected(1); + session + } + + #[test] + fn sequenced_unordered_channel_drops_older_late_frames() { + let mut sender = connected_session(1); + let mut receiver = connected_session(1); + let first = sender + .send( + "latest", + b"first".to_vec(), + CultNetRudpSendOptions { + reliable: false, + ordered: false, + sequenced: true, + now_ms: 1, + reliable_expire_after_ms: None, + }, + ) + .unwrap(); + let second = sender + .send( + "latest", + b"second".to_vec(), + CultNetRudpSendOptions { + reliable: false, + ordered: false, + sequenced: true, + now_ms: 2, + reliable_expire_after_ms: None, + }, + ) + .unwrap(); + + let delivered_second = receiver.receive(&second, 2).unwrap().delivered; + let delivered_first = receiver.receive(&first, 3).unwrap().delivered; + + assert_eq!(delivered_second.len(), 1); + assert_eq!(delivered_second[0].payload, b"second"); + assert!(delivered_first.is_empty()); + } +} diff --git a/vendor/cultnet-rs/src/schema_discovery.rs b/vendor/cultnet-rs/src/schema_discovery.rs new file mode 100644 index 0000000..2cc1420 --- /dev/null +++ b/vendor/cultnet-rs/src/schema_discovery.rs @@ -0,0 +1,396 @@ +use anyhow::Result; +use anyhow::anyhow; +use serde_json::Value; +use sha2::Digest; +use sha2::Sha256; +use std::collections::BTreeMap; +use std::collections::BTreeSet; + +use crate::CultNetMessage; +use crate::CultNetSchemaDescriptor; +use crate::CultNetSchemaKind; +use crate::CultNetWireContract; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultNetSchemaRegistration { + pub schema_id: String, + pub kind: CultNetSchemaKind, + pub wire_contracts: Vec, + pub schema_version: Option, + pub document_type: Option, + pub title: Option, + pub schema_json: Option, +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct CultNetSchemaCatalogOptions { + pub include_schema_json: bool, + pub schema_ids: Option>, + pub kinds: Option>, +} + +#[derive(Clone, Debug, Default)] +pub struct CultNetSchemaRegistry { + entries: BTreeMap, +} + +impl CultNetSchemaRegistry { + pub fn new() -> Self { + Self::default() + } + + pub fn register(&mut self, registration: CultNetSchemaRegistration) -> Result<()> { + if registration.schema_id.trim().is_empty() { + return Err(anyhow!("schema_id must be non-empty")); + } + if registration.wire_contracts.is_empty() { + return Err(anyhow!("wire_contracts must contain at least one entry")); + } + + let content_hash = if let Some(schema_json) = registration.schema_json.as_deref() { + canonical_schema_hash(schema_json)? + } else { + return Err(anyhow!( + "schema_json is required so discovery can advertise canonical hashes" + )); + }; + + self.entries.insert( + registration.schema_id.clone(), + CultNetSchemaDescriptor { + schema_id: registration.schema_id, + kind: registration.kind, + schema_version: registration.schema_version, + document_type: registration.document_type, + title: registration.title, + wire_contracts: registration.wire_contracts, + content_hash, + schema_json: registration.schema_json, + }, + ); + + Ok(()) + } + + pub fn get( + &self, + schema_id: &str, + include_schema_json: bool, + ) -> Option { + self.entries + .get(schema_id) + .map(|entry| sanitize_descriptor(entry, include_schema_json)) + } + + pub fn list(&self, options: &CultNetSchemaCatalogOptions) -> Vec { + let requested_ids = options + .schema_ids + .as_ref() + .map(|values| values.iter().cloned().collect::>()); + let requested_kinds = options + .kinds + .as_ref() + .map(|values| values.iter().copied().collect::>()); + + self.entries + .values() + .filter(|entry| { + if let Some(requested_ids) = &requested_ids + && !requested_ids.contains(&entry.schema_id) + { + return false; + } + + if let Some(requested_kinds) = &requested_kinds + && !requested_kinds.contains(&entry.kind) + { + return false; + } + + true + }) + .map(|entry| sanitize_descriptor(entry, options.include_schema_json)) + .collect() + } + + pub fn create_catalog_response(&self, request: &CultNetMessage) -> Result { + let CultNetMessage::SchemaCatalogRequest { + message_id, + include_schema_json, + schema_ids, + kinds, + } = request + else { + return Err(anyhow!( + "expected cultnet.schema_catalog_request.v0 for schema discovery" + )); + }; + + Ok(CultNetMessage::SchemaCatalogResponse { + message_id: message_id.clone(), + schemas: self.list(&CultNetSchemaCatalogOptions { + include_schema_json: include_schema_json.unwrap_or(false), + schema_ids: schema_ids.clone(), + kinds: kinds.clone(), + }), + }) + } +} + +fn sanitize_descriptor( + descriptor: &CultNetSchemaDescriptor, + include_schema_json: bool, +) -> CultNetSchemaDescriptor { + let mut clone = descriptor.clone(); + if !include_schema_json { + clone.schema_json = None; + } + clone +} + +fn canonical_schema_hash(schema_json: &str) -> Result { + let value: Value = serde_json::from_str(schema_json)?; + let canonical = stable_stringify(&value); + Ok(format!("{:x}", Sha256::digest(canonical.as_bytes()))) +} + +fn stable_stringify(value: &Value) -> String { + match value { + Value::Null => "null".to_string(), + Value::Bool(value) => value.to_string(), + Value::Number(value) => value.to_string(), + Value::String(value) => serde_json::to_string(value).expect("string serialization"), + Value::Array(values) => format!( + "[{}]", + values + .iter() + .map(stable_stringify) + .collect::>() + .join(",") + ), + Value::Object(values) => { + let mut entries = values.iter().collect::>(); + entries.sort_by(|(left, _), (right, _)| left.cmp(right)); + format!( + "{{{}}}", + entries + .into_iter() + .map(|(key, value)| { + format!( + "{}:{}", + serde_json::to_string(key).expect("key serialization"), + stable_stringify(value) + ) + }) + .collect::>() + .join(",") + ) + } + } +} + +pub fn builtin_schema_registry() -> Result { + let mut registry = CultNetSchemaRegistry::new(); + + for registration in [ + schema_registration( + include_str!("../contracts/cultnet.hello.schema.json"), + CultNetSchemaKind::WireMessage, + vec![CultNetWireContract::CultNetSchemaV0], + Some("cultnet.hello.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.document-mutation-contract.schema.json"), + CultNetSchemaKind::SharedContract, + vec![CultNetWireContract::CultNetSchemaV0], + 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, + vec![ + CultNetWireContract::CultNetSchemaV0, + CultNetWireContract::GameCultNetworkingV0, + ], + Some("cultnet.login.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.register.schema.json"), + CultNetSchemaKind::WireMessage, + vec![ + CultNetWireContract::CultNetSchemaV0, + CultNetWireContract::GameCultNetworkingV0, + ], + Some("cultnet.register.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.verify.schema.json"), + CultNetSchemaKind::WireMessage, + vec![ + CultNetWireContract::CultNetSchemaV0, + CultNetWireContract::GameCultNetworkingV0, + ], + Some("cultnet.verify.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.login-success.schema.json"), + CultNetSchemaKind::WireMessage, + vec![ + CultNetWireContract::CultNetSchemaV0, + CultNetWireContract::GameCultNetworkingV0, + ], + Some("cultnet.login_success.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.error.schema.json"), + CultNetSchemaKind::WireMessage, + vec![ + CultNetWireContract::CultNetSchemaV0, + CultNetWireContract::GameCultNetworkingV0, + ], + Some("cultnet.error.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.sample-change-name.schema.json"), + CultNetSchemaKind::WireMessage, + vec![ + CultNetWireContract::CultNetSchemaV0, + CultNetWireContract::GameCultNetworkingV0, + ], + Some("cultnet.sample.change_name.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.sample-chat.schema.json"), + CultNetSchemaKind::WireMessage, + vec![ + CultNetWireContract::CultNetSchemaV0, + CultNetWireContract::GameCultNetworkingV0, + ], + Some("cultnet.sample.chat.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.document-put.schema.json"), + CultNetSchemaKind::WireMessage, + vec![CultNetWireContract::CultNetSchemaV0], + Some("cultnet.document_put.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.document-delete.schema.json"), + CultNetSchemaKind::WireMessage, + vec![CultNetWireContract::CultNetSchemaV0], + Some("cultnet.document_delete.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.raw-document-record.schema.json"), + CultNetSchemaKind::SharedContract, + vec![CultNetWireContract::CultNetSchemaV0], + None, + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.document-put-raw.schema.json"), + CultNetSchemaKind::WireMessage, + vec![CultNetWireContract::CultNetSchemaV0], + Some("cultnet.document_put_raw.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.snapshot-request.schema.json"), + CultNetSchemaKind::WireMessage, + vec![CultNetWireContract::CultNetSchemaV0], + Some("cultnet.snapshot_request.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.snapshot-response.schema.json"), + CultNetSchemaKind::WireMessage, + vec![CultNetWireContract::CultNetSchemaV0], + Some("cultnet.snapshot_response.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.snapshot-response-raw.schema.json"), + CultNetSchemaKind::WireMessage, + vec![CultNetWireContract::CultNetSchemaV0], + Some("cultnet.snapshot_response_raw.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.schema-catalog-request.schema.json"), + CultNetSchemaKind::WireMessage, + vec![ + CultNetWireContract::CultNetSchemaV0, + CultNetWireContract::GameCultNetworkingV0, + ], + Some("cultnet.schema_catalog_request.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/cultnet.schema-catalog-response.schema.json"), + CultNetSchemaKind::WireMessage, + vec![ + CultNetWireContract::CultNetSchemaV0, + CultNetWireContract::GameCultNetworkingV0, + ], + Some("cultnet.schema_catalog_response.v0"), + None, + )?, + schema_registration( + include_str!("../contracts/ghostlight.agent-state.schema.json"), + CultNetSchemaKind::DocumentPayload, + vec![CultNetWireContract::CultNetSchemaV0], + Some("ghostlight.agent_state.v0"), + Some("ghostlight.agent-state"), + )?, + ] { + registry.register(registration)?; + } + + Ok(registry) +} + +fn schema_registration( + schema_json: &str, + kind: CultNetSchemaKind, + wire_contracts: Vec, + schema_version: Option<&str>, + document_type: Option<&str>, +) -> Result { + let value: Value = serde_json::from_str(schema_json)?; + let schema_id = value + .get("$id") + .and_then(Value::as_str) + .ok_or_else(|| anyhow!("schema is missing $id"))?; + let title = value + .get("title") + .and_then(Value::as_str) + .map(str::to_string); + + Ok(CultNetSchemaRegistration { + schema_id: schema_id.to_string(), + kind, + wire_contracts, + schema_version: schema_version.map(str::to_string), + document_type: document_type.map(str::to_string), + title, + schema_json: Some(schema_json.to_string()), + }) +} diff --git a/vendor/cultnet-rs/src/security.rs b/vendor/cultnet-rs/src/security.rs new file mode 100644 index 0000000..30aa841 --- /dev/null +++ b/vendor/cultnet-rs/src/security.rs @@ -0,0 +1,270 @@ +use aes_gcm::Aes256Gcm; +use aes_gcm::KeyInit; +use aes_gcm::Nonce; +use aes_gcm::aead::Aead; +use aes_gcm::aead::Payload; +use anyhow::Result; +use anyhow::anyhow; +use base64::Engine; +use base64::engine::general_purpose::URL_SAFE_NO_PAD; +use chrono::DateTime; +use chrono::TimeZone; +use chrono::Utc; +use hmac::Hmac; +use hmac::Mac; +use rand::RngCore; +use sha2::Digest; +use sha2::Sha256; + +const NONCE_LENGTH: usize = 12; +type HmacSha256 = Hmac; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultNetClientSecurityOptions { + pub connection_key: String, + encryption_key: [u8; 32], +} + +impl CultNetClientSecurityOptions { + pub fn new(connection_key: impl Into) -> Result { + let connection_key = connection_key.into(); + if connection_key.trim().is_empty() { + return Err(anyhow!("Connection key must be provided")); + } + let encryption_key = sha256(connection_key.as_bytes()); + Ok(Self { + connection_key, + encryption_key, + }) + } + + pub fn development() -> Self { + Self::new("gamecult-dev-connection-key").expect("development key is valid") + } + + pub fn encryption_key(&self) -> [u8; 32] { + self.encryption_key + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct CultNetServerSecurityOptions { + client: CultNetClientSecurityOptions, + pub session_signing_secret: String, + session_signing_key: [u8; 32], + pub is_development: bool, +} + +impl CultNetServerSecurityOptions { + pub fn new( + connection_key: impl Into, + session_signing_secret: impl Into, + is_development: bool, + ) -> Result { + let session_signing_secret = session_signing_secret.into(); + if session_signing_secret.trim().is_empty() { + return Err(anyhow!("Session signing secret must be provided")); + } + Ok(Self { + client: CultNetClientSecurityOptions::new(connection_key)?, + session_signing_key: sha256(session_signing_secret.as_bytes()), + session_signing_secret, + is_development, + }) + } + + pub fn development() -> Self { + Self::new( + "gamecult-dev-connection-key", + "gamecult-dev-session-signing-secret", + true, + ) + .expect("development security config is valid") + } + + pub fn to_client_options(&self) -> CultNetClientSecurityOptions { + self.client.clone() + } + + pub fn encryption_key(&self) -> [u8; 32] { + self.client.encryption_key() + } + + pub fn session_signing_key(&self) -> [u8; 32] { + self.session_signing_key + } +} + +pub trait CultNetEncryptionOptions { + fn encryption_key(&self) -> [u8; 32]; +} + +impl CultNetEncryptionOptions for CultNetClientSecurityOptions { + fn encryption_key(&self) -> [u8; 32] { + self.encryption_key() + } +} + +impl CultNetEncryptionOptions for CultNetServerSecurityOptions { + fn encryption_key(&self) -> [u8; 32] { + self.encryption_key() + } +} + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct ValidatedCultNetSessionToken { + pub user_id: String, + pub expires_at_utc: DateTime, +} + +pub struct CultNetSecret; + +impl CultNetSecret { + pub fn new_nonce() -> [u8; NONCE_LENGTH] { + let mut nonce = [0_u8; NONCE_LENGTH]; + rand::rng().fill_bytes(&mut nonce); + nonce + } + + pub fn encrypt_string( + input: Option<&str>, + nonce: &[u8], + options: &impl CultNetEncryptionOptions, + ) -> Result>> { + let Some(input) = input.filter(|value| !value.is_empty()) else { + return Ok(None); + }; + Ok(Some(Self::encrypt_bytes(input.as_bytes(), nonce, options)?)) + } + + pub fn decrypt_string( + encrypted: Option<&[u8]>, + nonce: Option<&[u8]>, + options: &impl CultNetEncryptionOptions, + ) -> Result> { + let (Some(encrypted), Some(nonce)) = (encrypted, nonce) else { + return Ok(None); + }; + let bytes = Self::decrypt_bytes(encrypted, nonce, options)?; + Ok(Some(String::from_utf8(bytes)?)) + } + + pub fn encrypt_bytes( + input: &[u8], + nonce: &[u8], + options: &impl CultNetEncryptionOptions, + ) -> Result> { + let nonce = validate_nonce(nonce)?; + let cipher = Aes256Gcm::new_from_slice(&options.encryption_key())?; + let encrypted = cipher + .encrypt( + Nonce::from_slice(nonce), + Payload { + msg: input, + aad: &[], + }, + ) + .map_err(|_| anyhow!("AES-GCM encryption failed"))?; + Ok(encrypted) + } + + pub fn decrypt_bytes( + encrypted: &[u8], + nonce: &[u8], + options: &impl CultNetEncryptionOptions, + ) -> Result> { + let nonce = validate_nonce(nonce)?; + let cipher = Aes256Gcm::new_from_slice(&options.encryption_key())?; + cipher + .decrypt( + Nonce::from_slice(nonce), + Payload { + msg: encrypted, + aad: &[], + }, + ) + .map_err(|_| anyhow!("AES-GCM decryption failed")) + } + + pub fn create_session_token( + user_id: &str, + expires_at_utc: DateTime, + options: &CultNetServerSecurityOptions, + ) -> Result { + let payload = format!("{}|{}", user_id, expires_at_utc.timestamp()); + let signature = hmac_sha256(&options.session_signing_key(), payload.as_bytes())?; + Ok(format!( + "{}.{}", + URL_SAFE_NO_PAD.encode(payload.as_bytes()), + URL_SAFE_NO_PAD.encode(signature) + )) + } + + pub fn try_validate_session_token( + token: Option<&str>, + options: &CultNetServerSecurityOptions, + ) -> Result> { + let Some(token) = token.filter(|value| !value.trim().is_empty()) else { + return Ok(None); + }; + let Some((payload_part, signature_part)) = token.split_once('.') else { + return Ok(None); + }; + let payload = URL_SAFE_NO_PAD.decode(payload_part)?; + let signature = URL_SAFE_NO_PAD.decode(signature_part)?; + let expected = hmac_sha256(&options.session_signing_key(), &payload)?; + if !constant_time_eq(&signature, &expected) { + return Ok(None); + } + let payload = String::from_utf8(payload)?; + let Some((user_id, expires_at)) = payload.split_once('|') else { + return Ok(None); + }; + let expires_at_seconds: i64 = expires_at.parse()?; + let Some(expires_at_utc) = Utc.timestamp_opt(expires_at_seconds, 0).single() else { + return Ok(None); + }; + if expires_at_utc <= Utc::now() { + return Ok(None); + } + Ok(Some(ValidatedCultNetSessionToken { + user_id: user_id.to_string(), + expires_at_utc, + })) + } + + pub fn to_base64_url(input: &[u8]) -> String { + URL_SAFE_NO_PAD.encode(input) + } + + pub fn from_base64_url(input: &str) -> Result> { + Ok(URL_SAFE_NO_PAD.decode(input)?) + } +} + +fn validate_nonce(nonce: &[u8]) -> Result<&[u8]> { + if nonce.len() != NONCE_LENGTH { + return Err(anyhow!("Invalid nonce")); + } + Ok(nonce) +} + +fn sha256(input: &[u8]) -> [u8; 32] { + Sha256::digest(input).into() +} + +fn hmac_sha256(key: &[u8], input: &[u8]) -> Result> { + let mut mac = ::new_from_slice(key)?; + mac.update(input); + Ok(mac.finalize().into_bytes().to_vec()) +} + +fn constant_time_eq(left: &[u8], right: &[u8]) -> bool { + if left.len() != right.len() { + return false; + } + left.iter() + .zip(right) + .fold(0_u8, |acc, (left, right)| acc | (left ^ right)) + == 0 +} diff --git a/vendor/cultnet-rs/src/transport.rs b/vendor/cultnet-rs/src/transport.rs new file mode 100644 index 0000000..55e0097 --- /dev/null +++ b/vendor/cultnet-rs/src/transport.rs @@ -0,0 +1,194 @@ +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, + pub reliable_packets_expired: 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, + reliable_expire_after_ms: 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 new file mode 100644 index 0000000..a650e28 --- /dev/null +++ b/vendor/cultnet-rs/tests/cultnet.rs @@ -0,0 +1,1352 @@ +use anyhow::Result; +use chrono::Duration; +use cultcache_rs::CultCache; +use cultcache_rs::DatabaseEntry; +use cultcache_rs::SingleFileMessagePackBackingStore; +use cultnet_rs::CultNetClientSecurityOptions; +use cultnet_rs::CultNetDocumentBinding; +use cultnet_rs::CultNetDocumentMutationContract; +use cultnet_rs::CultNetDocumentOperation; +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", + schema = "GhostlightAgentStateFixture" +)] +struct GhostlightAgentStateFixture { + #[cultcache(key = 0)] + schema_version: String, + #[cultcache(key = 1)] + agent_id: String, + #[cultcache(key = 2)] + display_name: String, +} + +#[test] +fn security_helpers_round_trip_encrypted_strings_and_validate_sessions() -> Result<()> { + let server_security = CultNetServerSecurityOptions::development(); + let client_security = server_security.to_client_options(); + let nonce = CultNetSecret::new_nonce(); + let encrypted = CultNetSecret::encrypt_string(Some("hello"), &nonce, &client_security)? + .expect("non-empty input encrypts"); + assert_eq!( + CultNetSecret::decrypt_string(Some(&encrypted), Some(&nonce), &server_security)?, + Some("hello".to_string()) + ); + + let token = CultNetSecret::create_session_token( + "runtime-face", + chrono::Utc::now() + Duration::minutes(1), + &server_security, + )?; + let validated = CultNetSecret::try_validate_session_token(Some(&token), &server_security)? + .expect("token validates before expiry"); + assert_eq!(validated.user_id, "runtime-face"); + Ok(()) +} + +#[test] +fn cultnet_schema_messages_round_trip_through_messagepack_frames() -> Result<()> { + let message = CultNetMessage::Hello { + runtime_id: "voidbot-main".to_string(), + runtime_kind: "rust-worker".to_string(), + agent_id: Some("void".to_string()), + role: None, + display_name: Some("Void".to_string()), + supported_document_types: Some(vec!["ghostlight.agent-state".to_string()]), + supported_mutation_contracts: Some(vec![CultNetDocumentMutationContract { + document_type: "ghostlight.agent-state".to_string(), + payload_schema_version: Some("ghostlight.agent_state.v0".to_string()), + operations: vec![ + CultNetDocumentOperation::Snapshot, + CultNetDocumentOperation::DocumentPut, + ], + authority: CultNetMutationAuthority::Coordinator, + 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![ + "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, + reliable_expire_after_ms: None, + }], + }], + }]), + supports_schema_catalog: Some(true), + }; + let payload = encode_cultnet_message_to_vec(&message, CultNetWireContract::CultNetSchemaV0)?; + let frame = encode_frame(&payload)?; + assert_eq!(&frame[..4], &(payload.len() as u32).to_be_bytes()); + + let mut framer = LengthPrefixedMessageFramer::new(); + assert!(framer.push(&frame[..2]).is_empty()); + let frames = framer.push(&frame[2..]); + assert_eq!(frames.len(), 1); + let decoded = + decode_cultnet_message_from_slice(&frames[0], CultNetWireContract::CultNetSchemaV0)?; + assert_eq!(decoded, message); + 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), + media_reliable_expire_after_ms: Some(75), + }, + ); + + 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, + channel.reliable_expire_after_ms, + ) + }) + .collect::>(); + assert_eq!( + channels, + vec![ + ( + "schema", + CultNetTransportDelivery::Reliable, + CultNetTransportOrdering::Ordered, + Some(64), + None + ), + ( + "latest", + CultNetTransportDelivery::Unreliable, + CultNetTransportOrdering::Sequenced, + Some(64), + None + ), + ( + "realtime", + CultNetTransportDelivery::Unreliable, + CultNetTransportOrdering::Unordered, + Some(64), + None + ), + ( + "media", + CultNetTransportDelivery::Reliable, + CultNetTransportOrdering::Unordered, + Some(64), + Some(75) + ), + ] + ); +} + +#[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_expires_bounded_reliable_media_resends() -> Result<()> { + let mut session = CultNetRudpSession::new(CultNetRudpSessionOptions { + connection_id: 100, + initial_sequence: 1, + resend_delay_ms: 20, + media_reliable_expire_after_ms: Some(50), + max_pending_reliable_packets: Some(1), + }); + session.receive( + &CultNetRudpPacket { + packet_type: CultNetRudpPacketType::Accept, + connection_id: 100, + 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( + "media", + b"frame-chunk".to_vec(), + CultNetRudpSendOptions { + reliable: true, + ordered: false, + now_ms: 10, + reliable_expire_after_ms: Some(50), + ..CultNetRudpSendOptions::default() + }, + )?; + + assert_eq!(session.pending_reliable_sequences(), vec![sent.sequence]); + assert!(session.due_resends(25).is_empty()); + assert_eq!( + session + .due_resends(35) + .iter() + .map(|packet| packet.sequence) + .collect::>(), + vec![sent.sequence] + ); + assert!(session.due_resends(61).is_empty()); + assert!(session.pending_reliable_sequences().is_empty()); + assert_eq!(session.reliable_packets_expired(), 1); + + session.send( + "media", + b"fresh-frame-chunk".to_vec(), + CultNetRudpSendOptions { + reliable: true, + ordered: false, + now_ms: 62, + reliable_expire_after_ms: Some(50), + ..CultNetRudpSendOptions::default() + }, + )?; + assert_eq!(session.reliable_packets_expired(), 1); + 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, + media_reliable_expire_after_ms: Some(75), + })?; + 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, + media_reliable_expire_after_ms: Some(75), + })?; + + 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_reports_expired_reliable_media_packets() -> Result<()> { + let server_socket = bind_udp_socket()?; + let client_socket = bind_udp_socket()?; + let server_addr = server_socket.local_addr()?; + let connection_id = 0x1020_3042; + let mut server = + CultNetRudpSocketTransportConnection::new(CultNetRudpSocketTransportOptions { + runtime_id: "rust-rudp-media-expiry-server".to_string(), + socket: server_socket, + mode: CultNetRudpSocketMode::Server, + remote_addr: None, + connection_id, + initial_sequence: 100, + resend_delay_ms: 5, + transport_id: None, + max_payload_bytes: None, + max_fragment_bytes: None, + max_pending_reliable_packets: None, + media_reliable_expire_after_ms: Some(25), + })?; + let mut client = + CultNetRudpSocketTransportConnection::new(CultNetRudpSocketTransportOptions { + runtime_id: "rust-rudp-media-expiry-client".to_string(), + socket: client_socket, + mode: CultNetRudpSocketMode::Client, + remote_addr: Some(server_addr), + connection_id, + initial_sequence: 1, + resend_delay_ms: 5, + transport_id: None, + max_payload_bytes: None, + max_fragment_bytes: None, + max_pending_reliable_packets: None, + media_reliable_expire_after_ms: Some(25), + })?; + + client.connect(b"join".to_vec())?; + pump_rudp_handshake(&mut client, &mut server)?; + client.send("media", b"late-frame".to_vec())?; + assert_eq!(client.stats().reliable_packets_expired, 0); + + thread::sleep(StdDuration::from_millis(40)); + client.poll_resends()?; + + assert_eq!(client.stats().reliable_packets_expired, 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, + media_reliable_expire_after_ms: Some(75), + })?; + 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, + media_reliable_expire_after_ms: Some(75), + })?; + + 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 { + nonce: CultNetSecret::to_base64_url(b"nonce"), + auth: CultNetSecret::to_base64_url(b"auth"), + password: CultNetSecret::to_base64_url(b"password"), + }; + let wire = + encode_cultnet_message_for_wire(&message, CultNetWireContract::GameCultNetworkingV0)?; + let items = wire.as_array().expect("legacy union is an array"); + assert_eq!(items[0].as_i64(), Some(0)); + assert_eq!( + items[1].as_array().unwrap()[0].as_slice(), + Some(&b"nonce"[..]) + ); + + let bytes = rmp_serde::to_vec(&wire)?; + let decoded = + decode_cultnet_message_from_slice(&bytes, CultNetWireContract::GameCultNetworkingV0)?; + assert_eq!(decoded, message); + Ok(()) +} + +#[test] +fn rust_decodes_typescript_generated_cultnet_frames() -> Result<()> { + let mut framer = LengthPrefixedMessageFramer::new(); + let hello_frames = framer.push(TS_HELLO_FRAME); + assert_eq!(hello_frames.len(), 1); + let hello = + decode_cultnet_message_from_slice(&hello_frames[0], CultNetWireContract::CultNetSchemaV0)?; + assert_eq!( + hello, + CultNetMessage::Hello { + runtime_id: "voidbot-main".to_string(), + runtime_kind: "node-worker".to_string(), + agent_id: Some("void".to_string()), + role: None, + display_name: Some("Void".to_string()), + 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, + } + ); + + let mut framer = LengthPrefixedMessageFramer::new(); + let login_frames = framer.push(TS_LEGACY_LOGIN_FRAME); + assert_eq!(login_frames.len(), 1); + let login = decode_cultnet_message_from_slice( + &login_frames[0], + CultNetWireContract::GameCultNetworkingV0, + )?; + assert_eq!( + login, + CultNetMessage::Login { + nonce: "bm9uY2U".to_string(), + auth: "YXV0aA".to_string(), + password: "cGFzc3dvcmQ".to_string(), + } + ); + Ok(()) +} + +#[test] +fn document_registry_advertises_mutation_contracts_with_bindings() -> Result<()> { + let mut registry = CultNetDocumentRegistry::new(); + let contract = CultNetDocumentMutationContract { + document_type: "ghostlight.agent-state".to_string(), + payload_schema_version: Some("ghostlight.agent_state.v0".to_string()), + operations: vec![ + CultNetDocumentOperation::Snapshot, + CultNetDocumentOperation::IntentSubmit, + CultNetDocumentOperation::ReceiptWatch, + ], + authority: CultNetMutationAuthority::Coordinator, + 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![ + "Intent documents are reviewed before cache mutation.".to_string(), + ]), + }; + registry.register( + CultNetDocumentBinding::for_entry::( + "ghostlight.agent_state.v0".to_string(), + ) + .with_mutation_contract(contract.clone()), + ); + + assert_eq!(registry.mutation_contracts(), vec![contract]); + Ok(()) +} + +#[test] +fn document_registry_replicates_typed_cultcache_state() -> Result<()> { + let temp = tempfile::tempdir()?; + 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.persona".to_string(), + display_name: "Persona".to_string(), + }; + + let mut registry = CultNetDocumentRegistry::new(); + registry.register(CultNetDocumentBinding::for_entry::< + GhostlightAgentStateFixture, + >("ghostlight.agent_state.v0".to_string())); + + let mut origin = CultCache::new(); + origin.register_entry_type::()?; + origin.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&origin_store)); + origin.pull_all_backing_stores()?; + origin.put("epiphany.persona", &payload)?; + + let snapshot = registry.create_snapshot_response(&origin, "snapshot-1", None, None)?; + + let mut target = CultCache::new(); + target.register_entry_type::()?; + target.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&target_store)); + target.pull_all_backing_stores()?; + let applied = + registry.apply_snapshot_response::(&mut target, &snapshot)?; + assert_eq!(applied, vec![payload.clone()]); + assert_eq!( + target.get_required::("epiphany.persona")?, + payload + ); + + let direct_put = registry.create_document_put_message( + "put-1", + "epiphany.persona", + &GhostlightAgentStateFixture { + 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, "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.msgpack"); + let target_store = temp.path().join("target-raw.msgpack"); + let payload = GhostlightAgentStateFixture { + schema_version: "ghostlight.agent_state.v0".to_string(), + agent_id: "epiphany.persona".to_string(), + display_name: "Persona".to_string(), + }; + + let mut registry = CultNetDocumentRegistry::new(); + registry.register(CultNetDocumentBinding::for_entry::< + GhostlightAgentStateFixture, + >("ghostlight.agent_state.v0".to_string())); + + let mut origin = CultCache::new(); + origin.register_entry_type::()?; + origin.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&origin_store)); + origin.pull_all_backing_stores()?; + 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.persona")?; + + let mut target = CultCache::new(); + target.register_entry_type::()?; + target.add_generic_backing_store(SingleFileMessagePackBackingStore::new(&target_store)); + target.pull_all_backing_stores()?; + let applied = registry + .apply_raw_snapshot_response::(&mut target, &raw_snapshot)?; + let target_envelope = + 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.persona")?, + payload + ); + Ok(()) +} + +#[test] +fn client_security_keeps_the_connection_key_visible_without_exposing_cipher_logic() -> Result<()> { + let options = CultNetClientSecurityOptions::development(); + assert_eq!(options.connection_key, "gamecult-dev-connection-key"); + assert_ne!(options.encryption_key(), [0_u8; 32]); + Ok(()) +} + +#[test] +fn builtin_schema_registry_advertises_canonical_ghostlight_schema_without_inline_body_by_default() +-> Result<()> { + let registry = builtin_schema_registry()?; + let response = registry.create_catalog_response(&CultNetMessage::SchemaCatalogRequest { + message_id: "catalog-1".to_string(), + include_schema_json: None, + schema_ids: None, + kinds: None, + })?; + + let CultNetMessage::SchemaCatalogResponse { schemas, .. } = response else { + panic!("expected catalog response"); + }; + + let ghostlight = schemas + .iter() + .find(|schema| schema.document_type.as_deref() == Some("ghostlight.agent-state")) + .expect("ghostlight agent-state schema is advertised"); + + assert_eq!(ghostlight.kind, CultNetSchemaKind::DocumentPayload); + assert_eq!( + ghostlight.schema_version.as_deref(), + Some("ghostlight.agent_state.v0") + ); + 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(()) +} + +#[test] +fn schema_discovery_round_trips_over_legacy_gamecult_contract_when_inline_schemas_are_requested() +-> Result<()> { + let registry = { + let mut registry = CultNetSchemaRegistry::new(); + registry.register(cultnet_rs::CultNetSchemaRegistration { + schema_id: "https://example.test/contracts/example.schema.json".to_string(), + kind: CultNetSchemaKind::SharedContract, + wire_contracts: vec![ + CultNetWireContract::CultNetSchemaV0, + CultNetWireContract::GameCultNetworkingV0, + ], + schema_version: None, + document_type: None, + title: Some("Example Schema".to_string()), + schema_json: Some( + r#"{ + "$schema":"https://json-schema.org/draft/2020-12/schema", + "$id":"https://example.test/contracts/example.schema.json", + "title":"Example Schema", + "type":"object", + "properties":{"value":{"type":"string"}}, + "required":["value"], + "additionalProperties":false + }"# + .to_string(), + ), + })?; + registry + }; + + let response = registry.create_catalog_response(&CultNetMessage::SchemaCatalogRequest { + message_id: "catalog-legacy".to_string(), + include_schema_json: Some(true), + schema_ids: None, + kinds: None, + })?; + let wire = + encode_cultnet_message_for_wire(&response, CultNetWireContract::GameCultNetworkingV0)?; + let bytes = rmp_serde::to_vec(&wire)?; + let decoded = + decode_cultnet_message_from_slice(&bytes, CultNetWireContract::GameCultNetworkingV0)?; + + let CultNetMessage::SchemaCatalogResponse { + message_id, + schemas, + } = decoded + else { + panic!("expected legacy schema catalog response"); + }; + + assert_eq!(message_id, "catalog-legacy"); + assert_eq!( + schemas[0].schema_id, + "https://example.test/contracts/example.schema.json" + ); + assert!( + schemas[0] + .schema_json + .as_deref() + .is_some_and(|schema| schema.contains("\"value\"")) + ); + Ok(()) +} diff --git a/vendor/cultnet-rs/tests/fixtures/cultnet-ts-hello.frame b/vendor/cultnet-rs/tests/fixtures/cultnet-ts-hello.frame new file mode 100644 index 0000000000000000000000000000000000000000..e2b22d50048ca9f140927ecaa1a9f5ec70affe1d GIT binary patch literal 160 zcmXZUu?oU45P;#nP>T=YQUoXI9-E^%OzuMNQt1o0yE_&{qTtl$vx@7_$6r;|?edb| zK`9voKBGLW&qOG&R<+C oO7v#hn*ejShDCCWoD}Sq`y5tzm?Fq^861mx9Go`4K`m+&KGeNK7ytkO literal 0 HcmV?d00001 diff --git a/vendor/cultnet-rs/tests/fixtures/cultnet-ts-legacy-login.frame b/vendor/cultnet-rs/tests/fixtures/cultnet-ts-legacy-login.frame new file mode 100644 index 0000000000000000000000000000000000000000..c6f335d37783e6ab66bf1cdfa02137995209a860 GIT binary patch literal 30 lcmZQzV33-`F!=~;UVdJ3>JgU2(vplL90iHR#pU@$DFBis3e^Ar literal 0 HcmV?d00001