v0.3.12-pre.008

crates/ksp-worker-raw-transaction-ingest-lib/unit_tests/runtime_resources.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-worker-raw-transaction-ingest-lib/unit_tests/runtime_resources.rs
-// version: 8
+// version: 9
 
 fn grpc_endpoint(cluster: &str) -> std::option::Option<ksp_onchain_transport_lib::YellowstoneGrpcEndpointSettings> {
     return grpc_endpoint_with_identity(cluster, "yellowstone-fixture", "fixture-provider");
@@ -1370,3 +1370,45 @@ fn pre_007_processing_frontier_compacts_settled_slots_to_pending_intervals() {
     assert_eq!(projection.processing_frontier_slot(), std::option::Option::Some(9));
     return;
 }
+
+#[test]
+fn pre_008_reconnect_replay_and_proven_gap_are_distinct_monotone_and_frontier_preserving() {
+    let (sender, receiver) = tokio::sync::watch::channel(crate::RawTransactionIngestProcessingFrontierProjection::empty());
+    let mut reporter = super::RawTransactionIngestProcessingFrontierReporter::new(sender);
+    assert!(reporter.observe_pending(42).is_ok());
+    assert!(reporter.observe_source_continuity(crate::RawTransactionIngestSourceState::Reconnecting, 0, 1, 0).is_ok());
+    let replaying = *receiver.borrow();
+    assert_eq!(replaying.hydration_pending(), 1);
+    assert_eq!(replaying.oldest_pending_slot(), std::option::Option::Some(42));
+    assert_eq!(replaying.source_state(), std::option::Option::Some(crate::RawTransactionIngestSourceState::Reconnecting));
+    assert_eq!(replaying.source_reconnect_total(), 0);
+    assert_eq!(replaying.source_replay_attempt_total(), 1);
+    assert_eq!(replaying.source_continuity_gap_total(), 0);
+    assert!(reporter.observe_source_continuity(crate::RawTransactionIngestSourceState::Active, 1, 1, 0).is_ok());
+    let gap = reporter.observe_source_continuity(crate::RawTransactionIngestSourceState::Reconnecting, 1, 2, 1);
+    assert!(gap.is_err());
+    let gap = match gap {
+        std::result::Result::Ok(()) => return,
+        std::result::Result::Err(value) => value,
+    };
+    assert_eq!(gap.code(), crate::ERROR_CODE_RAW_TRANSACTION_INGEST_RUNTIME_INVALID);
+    assert!(gap.context().iter().any(|context| {
+        return context.value() == "source.continuity_gap_proven";
+    }));
+    let proven = *receiver.borrow();
+    assert_eq!(proven.hydration_pending(), 1);
+    assert_eq!(proven.oldest_pending_slot(), std::option::Option::Some(42));
+    assert_eq!(proven.source_reconnect_total(), 1);
+    assert_eq!(proven.source_replay_attempt_total(), 2);
+    assert_eq!(proven.source_continuity_gap_total(), 1);
+    let regression = reporter.observe_source_continuity(crate::RawTransactionIngestSourceState::Active, 0, 2, 1);
+    assert!(regression.is_err());
+    let regression = match regression {
+        std::result::Result::Ok(()) => return,
+        std::result::Result::Err(value) => value,
+    };
+    assert!(regression.context().iter().any(|context| {
+        return context.value() == "source.continuity_counter_regression";
+    }));
+    return;
+}

crates/ksp-worker-raw-transaction-ingest-lib/unit_tests/snapshot.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-worker-raw-transaction-ingest-lib/unit_tests/snapshot.rs
-// version: 3
+// version: 4
 
 fn snapshot_foundation() -> std::option::Option<(crate::RawTransactionIngestSnapshotPublisher, crate::RawTransactionIngestSnapshotSource)> {
     let network = match ksp_store_lib::RawNetworkId::new("mainnet") {
@@ -53,6 +53,10 @@ fn pre_008_initial_snapshot_and_common_projection_are_exact() {
     assert_eq!(concrete.hydration_pending(), 0);
     assert_eq!(concrete.processing_frontier_slot(), std::option::Option::None);
     assert_eq!(concrete.oldest_pending_slot(), std::option::Option::None);
+    assert_eq!(concrete.source_state(), std::option::Option::None);
+    assert_eq!(concrete.source_reconnect_total(), 0);
+    assert_eq!(concrete.source_replay_attempt_total(), 0);
+    assert_eq!(concrete.source_continuity_gap_total(), 0);
     let common = ksp_worker_api::WorkerSnapshotSource::current(&source);
     assert_eq!(&common, concrete.worker_snapshot());
     return;
@@ -164,3 +168,34 @@ fn pre_007_processing_frontier_projection_is_latest_value_and_activity_aware() {
     assert_eq!(settled.worker_snapshot().activity(), ksp_worker_api::WorkerActivity::Idle);
     return;
 }
+
+#[test]
+fn pre_008_source_continuity_projection_preserves_processing_frontier_and_distinguishes_replay() {
+    let (mut publisher, source) = match snapshot_foundation() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let projection = crate::RawTransactionIngestProcessingFrontierProjection::new(2, std::option::Option::Some(40), std::option::Option::Some(41))
+        .with_source_continuity(std::option::Option::Some(crate::RawTransactionIngestSourceState::Reconnecting), 0, 1, 0);
+    assert!(publisher.record_processing_frontier(ksp_worker_api::WorkerState::Running, 0, 0, projection).is_ok());
+    let reconnecting = source.current();
+    assert_eq!(reconnecting.hydration_pending(), 2);
+    assert_eq!(reconnecting.processing_frontier_slot(), std::option::Option::Some(40));
+    assert_eq!(reconnecting.oldest_pending_slot(), std::option::Option::Some(41));
+    assert_eq!(reconnecting.source_state(), std::option::Option::Some(crate::RawTransactionIngestSourceState::Reconnecting));
+    assert_eq!(reconnecting.source_reconnect_total(), 0);
+    assert_eq!(reconnecting.source_replay_attempt_total(), 1);
+    assert_eq!(reconnecting.source_continuity_gap_total(), 0);
+    assert_eq!(reconnecting.worker_snapshot().activity(), ksp_worker_api::WorkerActivity::Active);
+    let projection = crate::RawTransactionIngestProcessingFrontierProjection::new(0, std::option::Option::Some(45), std::option::Option::None)
+        .with_source_continuity(std::option::Option::Some(crate::RawTransactionIngestSourceState::Active), 1, 1, 0);
+    assert!(publisher.record_processing_frontier(ksp_worker_api::WorkerState::Running, 0, 0, projection).is_ok());
+    let resumed = source.current();
+    assert_eq!(resumed.hydration_pending(), 0);
+    assert_eq!(resumed.processing_frontier_slot(), std::option::Option::Some(45));
+    assert_eq!(resumed.source_state(), std::option::Option::Some(crate::RawTransactionIngestSourceState::Active));
+    assert_eq!(resumed.source_reconnect_total(), 1);
+    assert_eq!(resumed.source_replay_attempt_total(), 1);
+    assert_eq!(resumed.worker_snapshot().activity(), ksp_worker_api::WorkerActivity::Idle);
+    return;
+}