moonpool 0.6.0

Deterministic simulation testing for distributed systems in Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

//! # Moonpool
//!
//! Deterministic simulation testing for distributed systems in Rust.
//!
//! Moonpool enables you to write distributed system logic once, test it with
//! simulated networking for reproducible debugging, then deploy with real
//! networking—all using identical application code.
//!
//! Inspired by [FoundationDB's simulation testing](https://apple.github.io/foundationdb/testing.html).
//!
//! ## Crate Architecture
//!
//! ```text
//! ┌─────────────────────────────────────────────────────────────┐
//! │              moonpool (this crate)                          │
//! │   Re-exports all functionality from sub-crates             │
//! ├──────────────────────────┬──────────────────────────────────┤
//! │  moonpool-transport      │       moonpool-sim               │
//! │  • Peer connections      │       • SimWorld runtime         │
//! │  • Wire format           │       • Chaos testing            │
//! │  • NetTransport + RPC    │       • Buggify macros           │
//! │  • #[service] macro      │       • 14 assertion macros      │
//! │    (via transport-derive)│       • Multiverse exploration   │
//! │                          │         (via moonpool-explorer)  │
//! ├──────────────────────────┴──────────────────────────────────┤
//! │                     moonpool-core                           │
//! │  Provider traits: Time, Task, Network, Random, Storage      │
//! │  Core types: UID, Endpoint, NetworkAddress                  │
//! └─────────────────────────────────────────────────────────────┘
//! ```
//!
//! ## Quick Start
//!
//! ```ignore
//! use moonpool::{SimulationBuilder, WorkloadTopology};
//!
//! SimulationBuilder::new()
//!     .topology(WorkloadTopology::ClientServer { clients: 2, servers: 1 })
//!     .run(|ctx| async move {
//!         // Your distributed system workload
//!     });
//! ```
//!
//! ## Which Crate to Use
//!
//! | Use case | Crate |
//! |----------|-------|
//! | Full framework (recommended) | `moonpool` |
//! | Provider traits only | `moonpool-core` |
//! | Simulation without transport | `moonpool-sim` |
//! | Transport without simulation | `moonpool-transport` |
//! | Fork-based exploration internals | `moonpool-explorer` |
//! | Proc-macro internals | `moonpool-transport-derive` |
//!
//! ## Documentation
//!
//! - [`moonpool_core`] - Provider traits and core types
//! - [`moonpool_sim`] - Simulation runtime and chaos testing
//! - [`moonpool_transport`] - Network transport layer

#![deny(missing_docs)]
#![allow(ambiguous_glob_reexports)]

// Re-export all public items from sub-crates
pub use moonpool_core::*;
pub use moonpool_sim::*;
pub use moonpool_transport::*;