mirror of
https://github.com/neondatabase/neon.git
synced 2026-01-14 17:02:56 +00:00
4be2223a4c
This PR contains the first version of a [FoundationDB-like](https://www.youtube.com/watch?v=4fFDFbi3toc) simulation testing for safekeeper and walproposer. ### desim This is a core "framework" for running determenistic simulation. It operates on threads, allowing to test syncronous code (like walproposer). `libs/desim/src/executor.rs` contains implementation of a determenistic thread execution. This is achieved by blocking all threads, and each time allowing only a single thread to make an execution step. All executor's threads are blocked using `yield_me(after_ms)` function. This function is called when a thread wants to sleep or wait for an external notification (like blocking on a channel until it has a ready message). `libs/desim/src/chan.rs` contains implementation of a channel (basic sync primitive). It has unlimited capacity and any thread can push or read messages to/from it. `libs/desim/src/network.rs` has a very naive implementation of a network (only reliable TCP-like connections are supported for now), that can have arbitrary delays for each package and failure injections for breaking connections with some probability. `libs/desim/src/world.rs` ties everything together, to have a concept of virtual nodes that can have network connections between them. ### walproposer_sim Has everything to run walproposer and safekeepers in a simulation. `safekeeper.rs` reimplements all necesary stuff from `receive_wal.rs`, `send_wal.rs` and `timelines_global_map.rs`. `walproposer_api.rs` implements all walproposer callback to use simulation library. `simulation.rs` defines a schedule – a set of events like `restart <sk>` or `write_wal` that should happen at time `<ts>`. It also has code to spawn walproposer/safekeeper threads and provide config to them. ### tests `simple_test.rs` has tests that just start walproposer and 3 safekeepers together in a simulation, and tests that they are not crashing right away. `misc_test.rs` has tests checking more advanced simulation cases, like crashing or restarting threads, testing memory deallocation, etc. `random_test.rs` is the main test, it checks thousands of random seeds (schedules) for correctness. It roughly corresponds to running a real python integration test in an environment with very unstable network and cpu, but in a determenistic way (each seed results in the same execution log) and much much faster. Closes #547 --------- Co-authored-by: Arseny Sher <sher-ars@yandex.ru>
55 lines
1.2 KiB
Rust
55 lines
1.2 KiB
Rust
use std::sync::Arc;
|
|
|
|
use rand::Rng;
|
|
|
|
use crate::proto::NodeEvent;
|
|
|
|
use super::{
|
|
chan::Chan,
|
|
network::TCP,
|
|
world::{Node, NodeId, World},
|
|
};
|
|
|
|
/// Abstraction with all functions (aka syscalls) available to the node.
|
|
#[derive(Clone)]
|
|
pub struct NodeOs {
|
|
world: Arc<World>,
|
|
internal: Arc<Node>,
|
|
}
|
|
|
|
impl NodeOs {
|
|
pub fn new(world: Arc<World>, internal: Arc<Node>) -> NodeOs {
|
|
NodeOs { world, internal }
|
|
}
|
|
|
|
/// Get the node id.
|
|
pub fn id(&self) -> NodeId {
|
|
self.internal.id
|
|
}
|
|
|
|
/// Opens a bidirectional connection with the other node. Always successful.
|
|
pub fn open_tcp(&self, dst: NodeId) -> TCP {
|
|
self.world.open_tcp(dst)
|
|
}
|
|
|
|
/// Returns a channel to receive node events (socket Accept and internal messages).
|
|
pub fn node_events(&self) -> Chan<NodeEvent> {
|
|
self.internal.node_events()
|
|
}
|
|
|
|
/// Get current time.
|
|
pub fn now(&self) -> u64 {
|
|
self.world.now()
|
|
}
|
|
|
|
/// Generate a random number in range [0, max).
|
|
pub fn random(&self, max: u64) -> u64 {
|
|
self.internal.rng.lock().gen_range(0..max)
|
|
}
|
|
|
|
/// Append a new event to the world event log.
|
|
pub fn log_event(&self, data: String) {
|
|
self.internal.log_event(data)
|
|
}
|
|
}
|