v0.3.7-pre.011

crates/ksp-job-backfill-lib/src/checkpoint.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-job-backfill-lib/src/checkpoint.rs
-// version: 2
+// version: 3
 
 /// Opaque caller-owned checkpoint for one controlled Backfill resumption.
 ///
@@ -43,6 +43,12 @@ impl crate::BackfillCheckpoint {
         return Self { job_id, scope_fingerprint, completed_prefix, resume_before };
     }
 
+    /// Reissues this opaque frontier for a new caller-owned Job identity without changing scope or progress.
+    pub(crate) fn reissue_for_job(mut self, job_id: ksp_job_api::JobId) -> Self {
+        self.job_id = job_id;
+        return self;
+    }
+
     /// Returns the internal exclusive `before` cursor used only by controlled Before resumption.
     pub(crate) const fn resume_before(&self) -> std::option::Option<&crate::BackfillSignature> {
         return self.resume_before.as_ref();

crates/ksp-job-backfill-lib/src/request.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-job-backfill-lib/src/request.rs
-// version: 5
+// version: 6
 
 use sha2::Digest; // rust-rules: trait-import
 
@@ -396,6 +396,19 @@ impl crate::BackfillRequest {
         return std::result::Result::Ok(self);
     }
 
+    /// Reissues a validated checkpoint onto a new Job lifecycle while preserving exact request semantics.
+    pub fn resume_for_job(&self, job_id: ksp_job_api::JobId, checkpoint: crate::BackfillCheckpoint) -> ksp_core_lib::Result<Self> {
+        let validation = crate::validate_request_checkpoint(&self.job_id, self.scope_fingerprint, self.scope.kind(), &checkpoint);
+        if let std::result::Result::Err(error) = validation {
+            return std::result::Result::Err(error);
+        }
+        let checkpoint = checkpoint.reissue_for_job(job_id.clone());
+        let mut resumed = self.clone();
+        resumed.job_id = job_id;
+        resumed.checkpoint = std::option::Option::None;
+        return resumed.with_checkpoint(checkpoint);
+    }
+
     /// Returns the validated optional checkpoint supplied for controlled resumption.
     #[must_use]
     pub const fn checkpoint(&self) -> std::option::Option<&crate::BackfillCheckpoint> {

crates/ksp-job-backfill-lib/unit_tests/request.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-job-backfill-lib/unit_tests/request.rs
-// version: 1
+// version: 2
 
 fn signature(character: char) -> std::option::Option<crate::BackfillSignature> {
     return match crate::BackfillSignature::new(character.to_string().repeat(crate::MIN_BACKFILL_SIGNATURE_TEXT_BYTES)) {
@@ -232,3 +232,71 @@ fn pre_005_scope_kind_and_anchor_are_distinct_semantics() {
     assert_ne!(before, after);
     return;
 }
+
+#[test]
+fn pre_011_resume_reissues_checkpoint_for_new_job_without_changing_scope_semantics() {
+    let network = match network("mainnet-beta") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let original_job = match job_id("backfill:resume-original") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let resumed_job = match job_id("backfill:resume-next") {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let request = crate::BackfillRequest::new(
+        original_job.clone(),
+        network,
+        ksp_onchain_transport_lib::HttpRoleName::new("backfill_pool"),
+        crate::BackfillCommitment::Finalized,
+        crate::BackfillScope::before_address(
+            ksp_core_lib::Pubkey::new_from_array([11_u8; 32]),
+            match signature('8') {
+                std::option::Option::Some(value) => value,
+                std::option::Option::None => return,
+            },
+        ),
+        100,
+        10,
+        1000,
+        4,
+        std::option::Option::Some(42),
+    );
+    let request = match request {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    let resume_before = match signature('9') {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return,
+    };
+    let checkpoint = crate::BackfillCheckpoint::new(original_job, request.scope_fingerprint(), 7, std::option::Option::Some(resume_before.clone()));
+    let resumed = request.resume_for_job(resumed_job.clone(), checkpoint);
+    assert!(resumed.is_ok());
+    let resumed = match resumed {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return,
+    };
+    assert_eq!(resumed.job_id(), &resumed_job);
+    assert_eq!(resumed.scope_fingerprint(), request.scope_fingerprint());
+    assert_eq!(resumed.network(), request.network());
+    assert_eq!(resumed.role(), request.role());
+    assert_eq!(resumed.commitment(), request.commitment());
+    assert_eq!(resumed.scope(), request.scope());
+    assert_eq!(resumed.page_size(), request.page_size());
+    assert_eq!(resumed.max_pages(), request.max_pages());
+    assert_eq!(resumed.max_candidates(), request.max_candidates());
+    assert_eq!(resumed.hydration_concurrency(), request.hydration_concurrency());
+    assert_eq!(resumed.min_context_slot(), request.min_context_slot());
+    let checkpoint = resumed.checkpoint();
+    assert!(checkpoint.is_some());
+    if let std::option::Option::Some(checkpoint) = checkpoint {
+        assert_eq!(checkpoint.job_id(), &resumed_job);
+        assert_eq!(checkpoint.scope_fingerprint(), request.scope_fingerprint());
+        assert_eq!(checkpoint.completed_prefix(), 7);
+        assert_eq!(checkpoint.resume_before(), std::option::Option::Some(&resume_before));
+    }
+}