v0.1.0-pre.076

kb-app-demo-desktop/src/demo_backfill.rs

@@ -1,5 +1,5 @@
 // file: kb-app-demo-desktop/src/demo_backfill.rs
-// version: 12
+// version: 15
 
 //! Tauri commands and UI payloads for bounded HTTP transaction backfills.
 
@@ -227,7 +227,103 @@ impl std::ops::Drop for crate::DemoBackfillRunGuard<'_> {
     }
 }
 
-pub(crate) fn build_role_options(
+pub(crate) fn demo_backfill_cancel(state: tauri::State<'_, crate::AppState>) -> bool {
+    let running = state.demo_backfill_running().load(std::sync::atomic::Ordering::Acquire);
+    state
+        .demo_backfill_cancel_requested()
+        .store(true, std::sync::atomic::Ordering::Release);
+    return running;
+}
+
+pub(crate) fn demo_backfill_options(
+    state: tauri::State<'_, crate::AppState>,
+) -> crate::DemoBackfillOptionsPayload {
+    let roles = build_role_options(state.http_pool().snapshot());
+    let default_role = if roles.iter().any(|item| return item.role == "history_backfill") {
+        std::option::Option::Some("history_backfill".to_string())
+    } else {
+        roles.first().map(|item| return item.role.clone())
+    };
+    let programs = kb_program_ids::registered_program_ids()
+        .iter()
+        .map(|entry| {
+            return crate::DemoBackfillProgramOption {
+                code: entry.code().to_string(),
+                program_id: entry.program_id().to_string(),
+            };
+        })
+        .collect();
+    return crate::DemoBackfillOptionsPayload {
+        roles,
+        programs,
+        default_role,
+        default_commitment: "confirmed".to_string(),
+        default_page_size: 100,
+        default_max_pages: 20,
+        default_max_concurrent_requests: 4,
+        default_max_retries: 2,
+        running: state.demo_backfill_running().load(std::sync::atomic::Ordering::Acquire),
+    };
+}
+
+pub(crate) async fn demo_backfill_execute(
+    app_handle: tauri::AppHandle,
+    state: tauri::State<'_, crate::AppState>,
+    request: crate::DemoBackfillRequest,
+) -> std::result::Result<crate::DemoBackfillSummaryPayload, std::string::String> {
+    let acquire_result = state.demo_backfill_running().compare_exchange(
+        false,
+        true,
+        std::sync::atomic::Ordering::AcqRel,
+        std::sync::atomic::Ordering::Acquire,
+    );
+    if acquire_result.is_err() {
+        return std::result::Result::Err("a backfill campaign is already running".to_string());
+    }
+    let _run_guard = crate::DemoBackfillRunGuard { running: state.demo_backfill_running() };
+    state
+        .demo_backfill_cancel_requested()
+        .store(false, std::sync::atomic::Ordering::Release);
+    let pipeline_request = match build_pipeline_request(request) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let profile = state.active_profile();
+    let store_options = match kb_store::PostgresStoreOptions::new(
+        profile.database.postgres.url.clone(),
+        profile.database.postgres.max_connections,
+        profile.database.postgres.connect_timeout_ms,
+        false,
+    ) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    let store = match kb_store::PostgresStore::connect(store_options).await {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    if let std::result::Result::Err(error) = store.initialize_store_schema().await {
+        return std::result::Result::Err(error.to_string());
+    }
+    let observer = crate::DemoBackfillObserver {
+        app_handle,
+        cancel_requested: state.demo_backfill_cancel_requested(),
+    };
+    let summary = match kb_pipeline::execute_http_backfill(
+        state.http_pool(),
+        &store,
+        &pipeline_request,
+        &observer,
+    )
+    .await
+    {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    return std::result::Result::Ok(summary_payload(summary));
+}
+
+fn build_role_options(
     snapshots: std::vec::Vec<kb_onchain_transport::HttpPoolClientSnapshot>,
 ) -> std::vec::Vec<crate::DemoBackfillRoleOption> {
     let mut role_methods = std::collections::BTreeMap::<
@@ -266,7 +362,7 @@ pub(crate) fn build_role_options(
     return output;
 }
 
-pub(crate) fn build_demo_backfill_pipeline_request(
+fn build_pipeline_request(
     request: DemoBackfillRequest,
 ) -> std::result::Result<kb_pipeline::BackfillRequest, std::string::String> {
     let source_result = match request.mode.trim() {
@@ -385,9 +481,7 @@ fn address_source(
     });
 }
 
-pub(crate) fn demo_backfill_summary_payload(
-    summary: kb_pipeline::BackfillSummary,
-) -> DemoBackfillSummaryPayload {
+fn summary_payload(summary: kb_pipeline::BackfillSummary) -> DemoBackfillSummaryPayload {
     return crate::DemoBackfillSummaryPayload {
         capture_session_id: summary.capture_session_id,
         filter_code: summary.filter_code,