use crate::layer2::sync::codec::{derive_delivery_id, derive_transfer_id};
use crate::layer2::sync::petri::evaluate_transfer_guard;
use crate::layer2::sync::service::SyncContractError;
use crate::layer2::sync::service::{MCardSyncEngine, TERMINAL_ERROR_CODES};
use crate::layer2::sync::types::{
RecordFrame, RetryOutcome, SyncOutboxEntry, TransferAttempt, TransferSendResult, TransitionPayload,
};
impl MCardSyncEngine {
pub fn enqueue_transfer(
&mut self,
target_node_id: &str,
records: Vec<RecordFrame>,
transitions: Vec<TransitionPayload>,
disambiguator: &str,
) -> Result<SyncOutboxEntry, SyncContractError> {
let mut sorted_hashes: Vec<String> = records.iter().map(|r| r.hash.clone()).collect();
sorted_hashes.sort();
let hashes_json: Vec<String> = sorted_hashes.iter().map(|h| format!("\"{h}\"")).collect();
let canon = format!(
"{{\"disambiguator\":\"{}\",\"records\":[{}],\"targetNodeId\":\"{}\",\"transitions\":{}}}",
disambiguator,
hashes_json.join(","),
target_node_id,
transitions.len()
);
let q_ref = format!("blake3:{}", blake3::hash(canon.as_bytes()).to_hex());
let transfer_id = derive_transfer_id(&q_ref);
let delivery_id = derive_delivery_id(&q_ref, target_node_id);
if let Some(existing) = self.outbox.get(&delivery_id) {
return Ok(existing.clone());
}
let previous_marking = self.transfer_marking.clone();
*self.transfer_marking.entry("p_source".to_string()).or_insert(0) += 1;
let gate = evaluate_transfer_guard(&self.transfer_marking, "t_enqueue_push", 1);
if !gate.enabled {
self.transfer_marking = previous_marking;
return Err(SyncContractError::new(
"guard-rejected",
format!("Enqueue rejected: {}", gate.reason.unwrap_or_else(|| "unknown reason".to_string())),
));
}
self.transfer_marking = gate.post_marking;
let entry = SyncOutboxEntry {
transfer_id,
delivery_id: delivery_id.clone(),
target_node_id: target_node_id.to_string(),
status: "in_flight".to_string(),
attempt_count: 0,
records,
transitions,
last_error: None,
error_code: None,
prior_transfer_id: None,
};
self.outbox.insert(delivery_id.clone(), entry.clone());
if let Err(err) = self.persist_outbox() {
self.outbox.remove(&delivery_id);
self.transfer_marking = previous_marking;
return Err(SyncContractError::new(
"storage-aborted",
format!("Failed to persist outbox for {delivery_id}: {err}"),
));
}
Ok(entry)
}
pub fn flush_outbox(&mut self) -> Result<Vec<SyncOutboxEntry>, SyncContractError> {
if self.is_disposed || self.transport.is_none() {
return Ok(self.outbox.values().cloned().collect());
}
let eligible: Vec<String> = self
.outbox
.iter()
.filter(|(_, e)| e.status == "in_flight" || e.status == "queued")
.map(|(id, _)| id.clone())
.collect();
for delivery_id in eligible {
let entry = match self.outbox.get(&delivery_id) {
Some(e) => e.clone(),
None => continue,
};
if !self.is_durably_queued(&entry) {
return Err(SyncContractError::new(
"storage-aborted",
format!("Durable outbox entry missing or mismatched for {delivery_id}"),
));
}
let attempt = TransferAttempt {
transfer_id: entry.transfer_id.clone(),
delivery_id: entry.delivery_id.clone(),
source_node_id: self.node_id.clone(),
target_node_id: entry.target_node_id.clone(),
record_hashes: entry.records.iter().map(|r| r.hash.clone()).collect(),
transitions: entry.transitions.clone(),
attempt_count: entry.attempt_count + 1,
};
let res = match self
.transport
.as_ref()
.expect("transport checked")
.send_transfer(&attempt, &entry.records)
{
Ok(r) => r,
Err(err) => TransferSendResult {
ok: false,
committed: false,
replayed: false,
transient: true,
error_code: Some("transport-transient".to_string()),
reason: Some(err),
},
};
let mut updated = entry.clone();
updated.attempt_count = attempt.attempt_count;
if res.ok && res.committed {
self.transfer_marking =
evaluate_transfer_guard(&self.transfer_marking, "t_commit_push", 1).post_marking;
updated.status = "committed".to_string();
} else if res.transient {
self.transfer_marking =
evaluate_transfer_guard(&self.transfer_marking, "t_retry", 1).post_marking;
updated.status = "in_flight".to_string();
updated.last_error = res.reason.clone();
updated.error_code =
Some(res.error_code.clone().unwrap_or_else(|| "transport-transient".to_string()));
} else {
self.transfer_marking =
evaluate_transfer_guard(&self.transfer_marking, "t_reject", 1).post_marking;
updated.status = "rejected".to_string();
updated.last_error = res.reason.clone();
updated.error_code =
Some(res.error_code.clone().unwrap_or_else(|| "guard-rejected".to_string()));
}
self.outbox.insert(delivery_id.clone(), updated);
if let Err(err) = self.persist_outbox() {
return Err(SyncContractError::new(
"storage-aborted",
format!("Failed to persist outbox for {delivery_id}: {err}"),
));
}
}
Ok(self.outbox.values().cloned().collect())
}
pub fn retry_transfer(&mut self, delivery_id: &str) -> RetryOutcome {
let Some(entry) = self.outbox.get(delivery_id).cloned() else {
return RetryOutcome {
ok: false,
error_code: Some("guard-rejected".to_string()),
reason: Some("Transfer is not in rejected status".to_string()),
..Default::default()
};
};
if entry.status != "rejected" {
return RetryOutcome {
ok: false,
error_code: Some("guard-rejected".to_string()),
reason: Some("Transfer is not in rejected status".to_string()),
..Default::default()
};
}
if let Some(code) = entry.error_code.as_deref() {
if TERMINAL_ERROR_CODES.contains(&code) {
return RetryOutcome {
ok: false,
error_code: Some(code.to_string()),
reason: Some("Terminal integrity failure cannot retry".to_string()),
..Default::default()
};
}
}
let g1 = evaluate_transfer_guard(&self.transfer_marking, "t_retry_transfer", 1);
if !g1.enabled {
return RetryOutcome {
ok: false,
error_code: Some("guard-rejected".to_string()),
reason: g1.reason,
..Default::default()
};
}
self.transfer_marking =
evaluate_transfer_guard(&g1.post_marking, "t_prepare_transfer", 1).post_marking;
let mut updated = entry.clone();
updated.status = "in_flight".to_string();
updated.prior_transfer_id = Some(entry.transfer_id.clone());
updated.transfer_id = format!("{}:retry:{}", entry.transfer_id, entry.attempt_count);
self.outbox.insert(delivery_id.to_string(), updated.clone());
let _ = self.persist_outbox();
RetryOutcome { ok: true, entry: Some(updated), ..Default::default() }
}
}