commit 3b485480f2b26fa48cf4776c981c1ddb5c8cd9a7
parent 4523530121ccb48371c5a0a86a710c301a93eb94
Author: triesap <tyson@radroots.org>
Date: Tue, 13 Oct 2026 05:36:16 +0000
state: select the first ready delivery target
- Select one ordered eligible target without claiming its lease.
- Cover two targets, exact retry timing, retained bytes and state reopen.
- Preserve explicit startup cleanup under Rust 1.99 native checks.
- Apply the Rustls patch and retain explicit dependency review debt.
Diffstat:
10 files changed, 270 insertions(+), 16 deletions(-)
diff --git a/Cargo.lock b/Cargo.lock
@@ -2143,9 +2143,9 @@ dependencies = [
[[package]]
name = "rustls"
-version = "0.23.43"
+version = "0.23.45"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0283386ce02abc0151e1761d08802dfe86c173b0b494af5cbc086574e453da06"
+checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
dependencies = [
"once_cell",
"ring",
diff --git a/radroots.service.source-lock.v3.toml b/radroots.service.source-lock.v3.toml
@@ -7,7 +7,7 @@ architecture = "radroots.crates.release.v2"
workspace_catalog_sha256 = "deca0c080deae187ff8186c0708903e42f41ea57f77c5f91581e23aa561164a4"
version = "0.1.0-alpha"
source_archive_sha256 = "89b8ace3f61167df43aca89917405d58b2aaf2ddea8fadfb21d351d76f184e68"
-cargo_lock_sha256 = "ccb7593a1cecf74e1caf6fafaf0ba57ac9df6b6e566d522621ef4bbb1665d42f"
+cargo_lock_sha256 = "9ca38f142305b30ba70c30154e89bc61d06979e03eb5b517e07fa08a459dd81a"
rust_version = "1.97.1"
host_feature_profile = "service-host"
diff --git a/src/nip46_work.rs b/src/nip46_work.rs
@@ -691,8 +691,6 @@ fn connect_permission(
#[cfg(test)]
mod tests {
- use std::error::Error as _;
-
use nostr::{
EventBuilder, JsonUtil as _, Keys, Kind, Tag, Timestamp,
UnsignedEvent as NostrUnsignedEvent,
diff --git a/src/provider_executor.rs b/src/provider_executor.rs
@@ -437,9 +437,7 @@ const fn capability_allowed_for_role(
#[cfg(test)]
mod tests {
- use std::error::Error as _;
-
- use nostr::{JsonUtil as _, Kind, Tag, Timestamp};
+ use nostr::{Kind, Tag, Timestamp};
use super::*;
use crate::{
diff --git a/src/provider_verification.rs b/src/provider_verification.rs
@@ -820,7 +820,6 @@ impl From<WireCapability> for MycProviderCapability {
#[cfg(test)]
mod tests {
- use std::error::Error as _;
use std::path::Path;
use nostr::nips::{nip04, nip44};
diff --git a/src/runtime_foundation.rs b/src/runtime_foundation.rs
@@ -371,7 +371,8 @@ pub async fn open_myc_runtime_foundation(
match compose_after_state_open(runtime, configuration, metadata, state).await {
Ok(foundation) => Ok(foundation),
- Err((error, state)) => {
+ Err(failure) => {
+ let (error, state) = *failure;
if state.close().await.is_err() {
Err(MycRuntimeFoundationError::new(
MycRuntimeFoundationErrorKind::Close,
@@ -388,11 +389,11 @@ async fn compose_after_state_open(
configuration: MycConfigDocumentV1,
metadata: MycStateMetadata,
state: MycStateHost,
-) -> Result<MycRuntimeFoundation, (MycRuntimeFoundationError, MycStateHost)> {
+) -> Result<MycRuntimeFoundation, Box<(MycRuntimeFoundationError, MycStateHost)>> {
let (providers, readiness, supervisor) =
match compose_runtime_components(&runtime, &configuration).await {
Ok(components) => components,
- Err(error) => return Err((error, state)),
+ Err(error) => return Err(Box::new((error, state))),
};
Ok(MycRuntimeFoundation {
runtime,
diff --git a/src/state_delivery.rs b/src/state_delivery.rs
@@ -1,5 +1,9 @@
//! Durable delivery-job identity, bounded target attempts, and lease evidence.
+#[cfg(all(test, any(target_os = "linux", target_os = "macos")))]
+#[path = "state_delivery_tests.rs"]
+mod tests;
+
use core::fmt;
use std::error::Error;
@@ -52,7 +56,7 @@ WHERE j.status IN ('pending', 'active')
AND t.active_attempt_id IS NULL
AND (t.next_attempt_at_unix_ms IS NULL OR t.next_attempt_at_unix_ms <= ?)
ORDER BY j.created_at_unix_ms, t.job_id, t.target_index
-LIMIT 2"#;
+LIMIT 1"#;
const READ_JOB_SQL: &str = r#"SELECT
CASE WHEN typeof(job_id) = 'blob' AND length(job_id) = 32
diff --git a/src/state_delivery_tests.rs b/src/state_delivery_tests.rs
@@ -0,0 +1,255 @@
+//! Isolated native coverage for delivery selection through the real repository.
+
+use std::{fs, os::unix::fs::PermissionsExt};
+
+use crate::nip46_wave_080_a::{
+ RECEIVED_AT_MS, configuration, connection_time, metadata, migration_evidence, runtime,
+};
+use crate::nip46_wave_080_b::{active_connection, atomic_response_request};
+use crate::{
+ MycDeliveryAttemptNonce, MycDeliveryAttemptOutcome, MycDeliveryClaim, MycDeliveryJobStatus,
+ MycDeliveryRelayId, MycDeliveryRetryJitter, MycDeliveryTargetStatus, MycDeliveryTimeUnixMs,
+ MycNip46CommitRequest, initialize_myc_state, open_myc_state_read_write,
+};
+
+fn time(offset_ms: u64) -> MycDeliveryTimeUnixMs {
+ MycDeliveryTimeUnixMs::new(RECEIVED_AT_MS + offset_ms).expect("fixture time")
+}
+
+#[tokio::test]
+async fn ready_target_selection_is_read_only_ordered_and_respects_delivery_state() {
+ let directory = tempfile::tempdir().expect("temporary state root");
+ let runtime = runtime(directory.path());
+ fs::create_dir_all(runtime.context().paths().state()).expect("state directory");
+ fs::set_permissions(
+ runtime.context().paths().state(),
+ fs::Permissions::from_mode(0o700),
+ )
+ .expect("state directory mode");
+ let metadata = metadata(&runtime);
+ let configuration = configuration();
+ let (applied_at, build) = migration_evidence();
+ initialize_myc_state(&runtime, &metadata, applied_at, &build)
+ .await
+ .expect("state initialization");
+ let host = open_myc_state_read_write(&runtime, &metadata, applied_at, &build)
+ .await
+ .expect("writable state");
+ let repository = host.repository();
+ assert_eq!(
+ repository
+ .next_ready_delivery_target(time(4_000))
+ .await
+ .expect("empty outbox selection"),
+ None
+ );
+
+ let (work, _, decision) = active_connection(&repository, &configuration).await;
+ let completion = MycNip46CommitRequest::new(
+ &work,
+ Some(&decision),
+ None,
+ connection_time(RECEIVED_AT_MS + 2_001),
+ )
+ .expect("connection completion");
+ let (request, signed_bytes) = atomic_response_request(&configuration, &completion);
+ let committed = repository
+ .commit_nip46_response(&request)
+ .await
+ .expect("atomic response and delivery commit");
+ let job_id = committed.record().response().delivery_job().id();
+ let primary = MycDeliveryRelayId::new("primary").expect("primary target");
+ let secondary = MycDeliveryRelayId::new("secondary").expect("secondary target");
+ let before = repository
+ .read_delivery_job(job_id)
+ .await
+ .expect("initial job read")
+ .expect("initial job");
+ assert_eq!(before.targets().len(), 2);
+ assert_eq!(before.targets()[0].relay_id(), &primary);
+ assert_eq!(before.targets()[1].relay_id(), &secondary);
+ assert!(before.targets().iter().all(|target| {
+ target.status() == MycDeliveryTargetStatus::Pending && target.attempt_count() == 0
+ }));
+
+ for _ in 0..2 {
+ assert_eq!(
+ repository
+ .next_ready_delivery_target(time(4_000))
+ .await
+ .expect("two ready targets must select the first"),
+ Some((job_id, primary.clone()))
+ );
+ }
+ assert_eq!(
+ repository
+ .read_delivery_job(job_id)
+ .await
+ .expect("job after selection")
+ .expect("retained job"),
+ before,
+ "selection must not mutate job or target state"
+ );
+
+ let first = match repository
+ .claim_delivery_target(
+ job_id,
+ &primary,
+ MycDeliveryAttemptNonce::from_injected_entropy([0xb1; 32]),
+ time(4_000),
+ )
+ .await
+ .expect("primary claim")
+ {
+ MycDeliveryClaim::Claimed(attempt) => attempt,
+ other => panic!("expected fresh primary claim: {other:?}"),
+ };
+ assert_eq!(
+ repository
+ .next_ready_delivery_target(time(4_001))
+ .await
+ .expect("skip leased primary"),
+ Some((job_id, secondary.clone()))
+ );
+ let second = match repository
+ .claim_delivery_target(
+ job_id,
+ &secondary,
+ MycDeliveryAttemptNonce::from_injected_entropy([0xb2; 32]),
+ time(4_001),
+ )
+ .await
+ .expect("secondary claim")
+ {
+ MycDeliveryClaim::Claimed(attempt) => attempt,
+ other => panic!("expected fresh secondary claim: {other:?}"),
+ };
+ assert_eq!(
+ repository
+ .next_ready_delivery_target(time(4_002))
+ .await
+ .expect("all targets leased"),
+ None
+ );
+ for (relay, attempt) in [(&primary, &first), (&secondary, &second)] {
+ repository
+ .mark_delivery_attempt_submitted(job_id, relay, attempt.id(), time(4_002))
+ .await
+ .expect("record synthetic submission evidence");
+ }
+ assert_eq!(
+ repository
+ .next_ready_delivery_target(time(4_003))
+ .await
+ .expect("all targets submitted"),
+ None
+ );
+ repository
+ .record_delivery_attempt_outcome(
+ job_id,
+ &primary,
+ first.id(),
+ MycDeliveryAttemptOutcome::Delivered,
+ MycDeliveryRetryJitter::new(0).expect("zero jitter"),
+ time(4_003),
+ )
+ .await
+ .expect("synthetic primary acknowledgement");
+ let retryable = repository
+ .record_delivery_attempt_outcome(
+ job_id,
+ &secondary,
+ second.id(),
+ MycDeliveryAttemptOutcome::TransportFailed,
+ MycDeliveryRetryJitter::new(200).expect("bounded jitter"),
+ time(4_003),
+ )
+ .await
+ .expect("synthetic retryable secondary outcome");
+ assert_eq!(retryable.status(), MycDeliveryJobStatus::Active);
+ assert_eq!(retryable.targets()[1].next_attempt_at(), Some(time(4_203)));
+ assert_eq!(
+ repository
+ .next_ready_delivery_target(time(4_202))
+ .await
+ .expect("retry not yet due"),
+ None
+ );
+ assert_eq!(
+ repository
+ .next_ready_delivery_target(time(4_203))
+ .await
+ .expect("retry due at exact boundary"),
+ Some((job_id, secondary.clone()))
+ );
+ let retry = match repository
+ .claim_delivery_target(
+ job_id,
+ &secondary,
+ MycDeliveryAttemptNonce::from_injected_entropy([0xb3; 32]),
+ time(4_203),
+ )
+ .await
+ .expect("secondary retry claim")
+ {
+ MycDeliveryClaim::Claimed(attempt) => attempt,
+ other => panic!("expected fresh retry claim: {other:?}"),
+ };
+ assert_eq!(retry.number(), 2);
+ repository
+ .mark_delivery_attempt_submitted(job_id, &secondary, retry.id(), time(4_204))
+ .await
+ .expect("record retry submission evidence");
+ let delivered = repository
+ .record_delivery_attempt_outcome(
+ job_id,
+ &secondary,
+ retry.id(),
+ MycDeliveryAttemptOutcome::Delivered,
+ MycDeliveryRetryJitter::new(0).expect("zero jitter"),
+ time(4_205),
+ )
+ .await
+ .expect("synthetic retry acknowledgement");
+ assert_eq!(delivered.status(), MycDeliveryJobStatus::Delivered);
+ assert_eq!(
+ repository
+ .next_ready_delivery_target(time(4_206))
+ .await
+ .expect("terminal job is ineligible"),
+ None
+ );
+ let retained = repository
+ .read_nip46_response(job_id)
+ .await
+ .expect("response read")
+ .expect("retained response");
+ assert_eq!(retained.signed_response_bytes(), signed_bytes);
+ repository
+ .verify_delivery_invariants()
+ .await
+ .expect("delivery invariants after selection and claims");
+ host.close().await.expect("state close");
+
+ let reopened = open_myc_state_read_write(&runtime, &metadata, applied_at, &build)
+ .await
+ .expect("reopen state");
+ let repository = reopened.repository();
+ assert_eq!(
+ repository
+ .next_ready_delivery_target(time(4_207))
+ .await
+ .expect("terminal job remains ineligible after reopen"),
+ None
+ );
+ assert_eq!(
+ repository
+ .read_nip46_response(job_id)
+ .await
+ .expect("reopened response read")
+ .expect("reopened response")
+ .signed_response_bytes(),
+ signed_bytes
+ );
+ reopened.close().await.expect("reopened state close");
+}
diff --git a/src/transport_nostr_adapter.rs b/src/transport_nostr_adapter.rs
@@ -650,8 +650,6 @@ fn configuration_integer(
#[cfg(test)]
mod tests {
- use std::error::Error as _;
-
use nostr::{EventBuilder, JsonUtil as _, Keys};
use radroots_transport::{
outcome::{DeliveryOutcome, Retryability},
diff --git a/supply-chain/config.toml b/supply-chain/config.toml
@@ -793,8 +793,9 @@ version = "1.1.4"
criteria = "safe-to-deploy"
[[exemptions.rustls]]
-version = "0.23.43"
+version = "0.23.45"
criteria = "safe-to-deploy"
+notes = "Existing full-crate review debt retained. The exact 0.23.43 to 0.23.45 package delta was reviewed while applying the upstream patch for RUSTSEC-2026-0285; this is not an independent full-crate audit. No advisory exception was added."
[[exemptions.rustls-pki-types]]
version = "1.15.1"