v0.3.14-pre.010

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: 31
+// version: 32
 
 fn grpc_endpoint(cluster: &str) -> std::option::Option<ksp_onchain_transport_lib::YellowstoneGrpcEndpointSettings> {
     return grpc_endpoint_with_identity(cluster, "yellowstone-fixture", "fixture-provider");
@@ -4142,3 +4142,82 @@ fn v0_3_14_pre_009_inventory_health_projection_tracks_reconciled_coverage() {
     assert!(reconciled.future_target_coverage());
     return;
 }
+
+#[test]
+fn v0_3_14_pre_010_fair_scheduler_alternates_nominal_and_repair_with_bounded_burst() {
+    assert_eq!(super::MAX_RAW_TRANSACTION_INGEST_REPAIR_BURST, 1);
+    let mut state = super::RawTransactionIngestFairTurnState {
+        active: false,
+        last_granted: std::option::Option::None,
+        next_ticket: 3,
+        waiters: std::collections::VecDeque::from([
+            (1, super::RawTransactionIngestTrafficClass::Nominal),
+            (2, super::RawTransactionIngestTrafficClass::Repair),
+        ]),
+    };
+    assert_eq!(super::fair_turn_selected_ticket(&state), std::option::Option::Some(1));
+    state.last_granted = std::option::Option::Some(super::RawTransactionIngestTrafficClass::Nominal);
+    assert_eq!(super::fair_turn_selected_ticket(&state), std::option::Option::Some(2));
+    state.last_granted = std::option::Option::Some(super::RawTransactionIngestTrafficClass::Repair);
+    assert_eq!(super::fair_turn_selected_ticket(&state), std::option::Option::Some(1));
+    let _removed = state.waiters.pop_front();
+    assert_eq!(super::fair_turn_selected_ticket(&state), std::option::Option::Some(2));
+    return;
+}
+
+#[test]
+fn v0_3_14_pre_010_fair_waiter_bound_is_checked_and_released_without_reserved_capacity() {
+    assert!(super::validate_repair_fairness_contract(1, 1).is_ok());
+    assert_eq!(super::repair_block_fetch_limit(1), 1);
+    assert_eq!(super::repair_block_fetch_limit(4), 4);
+    assert_eq!(super::repair_block_fetch_limit(64), 4);
+    let gate = std::sync::Arc::new(super::RawTransactionIngestFairTurnGate::new(1));
+    let first = super::RawTransactionIngestFairWaiterGuard::register(std::sync::Arc::clone(&gate), super::RawTransactionIngestTrafficClass::Repair);
+    let first = match first {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert!(super::RawTransactionIngestFairWaiterGuard::register(std::sync::Arc::clone(&gate), super::RawTransactionIngestTrafficClass::Nominal,).is_err());
+    std::mem::drop(first);
+    assert!(super::RawTransactionIngestFairWaiterGuard::register(gate, super::RawTransactionIngestTrafficClass::Nominal).is_ok());
+    return;
+}
+
+#[tokio::test]
+async fn v0_3_14_pre_010_nominal_and_repair_hydration_share_one_capacity_one_permit_pool() {
+    let registry = std::sync::Arc::new(super::RawTransactionIngestGlobalHydrationRegistry::new(2, 1));
+    let nominal = registry.acquire_hydration_permit(super::RawTransactionIngestTrafficClass::Nominal).await;
+    let nominal = match nominal {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let repair_registry = std::sync::Arc::clone(&registry);
+    let repair = tokio::spawn(async move {
+        return repair_registry.acquire_hydration_permit(super::RawTransactionIngestTrafficClass::Repair).await;
+    });
+    tokio::task::yield_now().await;
+    assert!(!repair.is_finished());
+    std::mem::drop(nominal);
+    let repair = match repair.await {
+        std::result::Result::Ok(std::result::Result::Ok(value)) => value,
+        std::result::Result::Ok(std::result::Result::Err(_)) | std::result::Result::Err(_) => return,
+    };
+    assert_eq!(registry.hydration_permits.available_permits(), 0);
+    std::mem::drop(repair);
+    assert_eq!(registry.hydration_permits.available_permits(), 1);
+    return;
+}
+
+#[tokio::test]
+async fn v0_3_14_pre_010_repair_only_progresses_when_existing_capacity_is_one() {
+    let registry = super::RawTransactionIngestGlobalHydrationRegistry::new(1, 1);
+    let permit = registry.acquire_hydration_permit(super::RawTransactionIngestTrafficClass::Repair).await;
+    let permit = match permit {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(registry.hydration_permits.available_permits(), 0);
+    std::mem::drop(permit);
+    assert_eq!(registry.hydration_permits.available_permits(), 1);
+    return;
+}