aboutsummaryrefslogtreecommitdiffstats
path: root/src/simtest
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-17 04:19:29 +0000
committertv <tv@krebsco.de>2026-11-17 05:33:20 +0100
commitd651080e4782a3d19bf5469ff42ab70ddfeb727e (patch)
tree6bf7f986f32a27c1917fd8aa30e0a296b33c8a6e /src/simtest
parent5439b2e6b27a55a1da252cf745d0557686e9c815 (diff)
simtest: events written beyond a compaction's base go again (row 12)
A swarm holding a store compacts: events written beyond the base, on nodes that switch later, are put again in the new epoch, and every node holds every event, reads the same, and refused no change.
Diffstat (limited to 'src/simtest')
-rw-r--r--src/simtest/holding.rs92
1 files changed, 92 insertions, 0 deletions
diff --git a/src/simtest/holding.rs b/src/simtest/holding.rs
index ba33470..187488e 100644
--- a/src/simtest/holding.rs
+++ b/src/simtest/holding.rs
@@ -922,3 +922,95 @@ async fn federation_attack_33() {
);
assert_eq!(reads(&forks[1].1), Some((Id::of(&crafted_root), None)));
}
+
+/// Every node of `nodes` on generation `generation` and ready, within `timeout`.
+async fn on_generation(sim: &Sim, nodes: &[AppState], generation: u64, timeout: Duration) {
+ sim.wait_until(
+ &format!("every node is ready on generation {generation}"),
+ timeout,
+ move || async move {
+ for node in nodes {
+ if node.local_epoch().generation != generation || !node.is_ready().await {
+ return false;
+ }
+ }
+ true
+ },
+ )
+ .await;
+}
+
+/// The compaction `node` proposes: its ID.
+async fn compact(node: &AppState) -> String {
+ let (status, report) =
+ crate::remake::testing::start(node.clone(), serde_json::json!({ "kind": "compact" }), None)
+ .await;
+ assert!(status.is_success(), "proposal refused: {status} {report}");
+ report["id"].as_str().expect("a remake's ID").to_owned()
+}
+
+/// Events written beyond a base, on nodes that switch and on nodes that don't yet: put
+/// again in the new epoch, the same events, the same state; and no change refused.
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn store_attack_12() {
+ let sim = Sim::with_identity(91);
+ let (tv, lass, makefu) = three();
+ let (_, root, id) = federation(&[(&tv, &["a"]), (&lass, &["b"]), (&makefu, &["c"])]);
+ let nodes = started(
+ &sim,
+ &root,
+ vec![
+ ("a", holding("tv")),
+ ("b", holding("lass")),
+ ("c", holding("makefu")),
+ ],
+ )
+ .await;
+ let all = &nodes;
+ let before = tv.write(&[id], "home/tv/before", s("1"));
+ put(&nodes[0], &[&before]).await;
+ let held = [Id::of(&before)];
+ sim.wait_until("every node holds tv's write", LONG, move || async move {
+ all.iter().all(|node| holds(node, &held))
+ })
+ .await;
+
+ let remake = compact(&nodes[0]).await;
+ let remake = remake.as_str();
+ sim.wait_until("b and c hold it committed", LONG, move || async move {
+ for node in &all[1..] {
+ let committed = crate::remake::testing::report(node, remake)
+ .await
+ .is_some_and(|report| report["phase"] == "committed");
+ if !committed {
+ return false;
+ }
+ }
+ true
+ })
+ .await;
+ // Beyond its base, on nodes that haven't switched yet.
+ let during = [
+ lass.write(&[Id::of(&before)], "home/lass/during", s("2")),
+ makefu.write(&[id], "home/makefu/during", s("3")),
+ ];
+ put(&nodes[1], &[&during[0]]).await;
+ put(&nodes[2], &[&during[1]]).await;
+ on_generation(&sim, &nodes, 1, Duration::from_secs(60)).await;
+ let after = tv.write(&[Id::of(&during[0])], "home/tv/after", s("4"));
+ put(&nodes[0], &[&after]).await;
+
+ let every = [&before, &during[0], &during[1], &after].map(|event| Id::of(event));
+ sim.wait_until("every node holds every event", LONG, move || async move {
+ all.iter().all(|node| holds(node, &every))
+ })
+ .await;
+ let read: Vec<Option<Counts>> = nodes.iter().map(counts).collect();
+ assert!(read.iter().all(|counts| counts == &read[0]), "{read:?}");
+ for node in &nodes {
+ let refused = crate::locks::MutexExt::lock_or_recover(&*node.screening)
+ .refused()
+ .count();
+ assert_eq!(refused, 0, "a change refused");
+ }
+}