74 lines
3.2 KiB
Rust
74 lines
3.2 KiB
Rust
//! # chronogrid_net
|
|
//!
|
|
//! P2P mesh networking layer for ChronoGrid.
|
|
//!
|
|
//! Provides libp2p-based peer discovery and CRDT delta synchronization over
|
|
//! QUIC with Noise XK encryption.
|
|
//!
|
|
//! ## Module Overview
|
|
//!
|
|
//! | Module | Responsibility |
|
|
//! |-----------------|-------------------------------------------------------------------|
|
|
//! | [`error`] | Unified error type (`NetError`) and `NetResult<T>` alias |
|
|
//! | [`identity`] | Ed25519 node keypair, `NodeId` derivation, file persistence |
|
|
//! | [`swarm_key`] | 256-bit pre-shared `SwarmKey` for cluster authentication |
|
|
//! | [`peer_event`] | `PeerEvent` enum — unified peer lifecycle events |
|
|
//! | [`transport`] | TCP + Noise XK + Yamux transport builder; keypair conversion |
|
|
//! | [`discovery`] | `MdnsDiscovery` (LAN) and `KademliaDht` (WAN) peer discovery |
|
|
//! | [`sync`] | `VectorClock`, `DeltaPacket`, `SyncProtocol`, `GossipsubBroadcast`, `NetEvent` |
|
|
//! | [`swarm_manager`] | `SwarmManager` event loop, `SwarmHandle` public API, `ChronoGridBehaviour` composite |
|
|
//!
|
|
//! ## Quick Start
|
|
//!
|
|
//! ```rust,no_run
|
|
//! use std::path::Path;
|
|
//! use chronogrid_net::identity::load_or_create_identity;
|
|
//! use chronogrid_net::swarm_key::SwarmKey;
|
|
//! use chronogrid_net::transport::{build_transport, TransportConfig};
|
|
//! use chronogrid_net::sync::{VectorClock, DeltaPacket, SyncProtocol};
|
|
//! use chronogrid_net::swarm_manager::{SwarmManager, SwarmHandle};
|
|
//!
|
|
//! // Load or generate a persistent node identity.
|
|
//! let identity = load_or_create_identity(Path::new("/var/lib/chronogrid/identity.json"))
|
|
//! .expect("identity");
|
|
//! println!("Node ID: {}", identity.node_id());
|
|
//!
|
|
//! // Load or generate the cluster swarm key.
|
|
//! let swarm_key = SwarmKey::load_or_create(Path::new("/var/lib/chronogrid/swarm.key"))
|
|
//! .expect("swarm key");
|
|
//! println!("Swarm fingerprint: {}", swarm_key.fingerprint());
|
|
//!
|
|
//! // Build the TCP + Noise transport.
|
|
//! let transport = build_transport(&identity, &swarm_key).expect("transport");
|
|
//!
|
|
//! // Build the transport config (used by SwarmManager).
|
|
//! let config = TransportConfig::from_swarm_key(&swarm_key);
|
|
//! println!("User-agent: {}", config.user_agent());
|
|
//!
|
|
//! // Build a vector clock for delta sync.
|
|
//! let mut clock = VectorClock::new();
|
|
//! clock.update("entity-uuid-1", "1724000000000-0001-ab12");
|
|
//! ```
|
|
|
|
pub mod discovery;
|
|
pub mod error;
|
|
pub mod identity;
|
|
pub mod peer_event;
|
|
pub mod swarm_key;
|
|
pub mod swarm_manager;
|
|
pub mod sync;
|
|
pub mod transport;
|
|
|
|
// Re-export the most commonly used types at the crate root for convenience.
|
|
pub use error::{NetError, NetResult};
|
|
pub use identity::{NodeId, NodeIdentity};
|
|
pub use peer_event::PeerEvent;
|
|
pub use swarm_key::SwarmKey;
|
|
pub use swarm_manager::{ChronoGridBehaviour, SwarmHandle, SwarmManager};
|
|
pub use sync::{DeltaPacket, GossipEvent, NetEvent, SyncProtocol, VectorClock};
|
|
pub use transport::{TransportConfig, build_transport, peer_id_from_identity};
|
|
|
|
/// Re-export `libp2p::PeerId` so downstream crates (e.g. `chronogrid_core`
|
|
/// tests) can use it without a direct `libp2p` dependency.
|
|
pub use libp2p::PeerId;
|