use std::fmt;
use std::sync::{Arc, Mutex, MutexGuard};
use ed25519_dalek::{Signature, Signer as _, SigningKey, Verifier as _, VerifyingKey};
use super::device_state::{DevicePrimaryTestOnly, PrimaryShared};
use super::store::Store;
use crate::v2::checkpoint_ack::V2CheckpointAcknowledgement;
use crate::v2::claim_store::{V2AuthoritativeClock, V2StoreError};
use crate::v2::context::V2Context;
use crate::v2::errors::{V2Error, V2ErrorClass, V2Result};
use crate::v2::release::V2ReceiptCheckpoint;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DeviceErrorTestOnly {
PowerLoss,
StorageFull,
StateMismatch,
Frozen,
NotAcknowledged,
Store(V2StoreError),
}
impl fmt::Display for DeviceErrorTestOnly {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
DeviceErrorTestOnly::PowerLoss => f.write_str("v2reference: power lost during the device checkpoint submission"),
DeviceErrorTestOnly::StorageFull => f.write_str("v2reference: device checkpoint storage is full"),
DeviceErrorTestOnly::StateMismatch => {
f.write_str("v2reference: submission does not extend the device checkpoint head")
}
DeviceErrorTestOnly::Frozen => f.write_str("v2reference: device checkpoint is frozen after a conflicting entry"),
DeviceErrorTestOnly::NotAcknowledged => f.write_str(super::store::ERR_NOT_ACKNOWLEDGED),
DeviceErrorTestOnly::Store(e) => write!(f, "{e:?}"),
}
}
}
impl std::error::Error for DeviceErrorTestOnly {}
impl From<DeviceErrorTestOnly> for V2StoreError {
fn from(e: DeviceErrorTestOnly) -> Self {
match e {
DeviceErrorTestOnly::Store(inner) => inner,
other => V2StoreError::Unavailable(other.to_string()),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum DevicePowerLoss {
#[default]
Ok,
BeforeCommit,
AfterCommit,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DeviceAcknowledgementTestOnly {
pub log_id: String,
pub sequence: i64,
pub entry_hash: Vec<u8>,
pub state_digest: Vec<u8>,
pub timestamp: i64,
pub signature: Vec<u8>,
}
fn lp_bytes(out: &mut Vec<u8>, b: &[u8]) {
out.extend_from_slice(&(b.len() as u64).to_be_bytes());
out.extend_from_slice(b);
}
fn device_ack_message(a: &DeviceAcknowledgementTestOnly) -> Vec<u8> {
let mut m = b"ratify-test-device-checkpoint-v2\0".to_vec();
lp_bytes(&mut m, a.log_id.as_bytes());
m.extend_from_slice(&(a.sequence as u64).to_be_bytes());
lp_bytes(&mut m, &a.entry_hash);
lp_bytes(&mut m, &a.state_digest);
m.extend_from_slice(&(a.timestamp as u64).to_be_bytes());
m
}
pub fn verify_device_acknowledgement_test_only(public: &[u8], a: &DeviceAcknowledgementTestOnly) -> Result<(), String> {
let refused = || "v2reference: device acknowledgement signature does not verify".to_string();
let key: [u8; 32] = public.try_into().map_err(|_| refused())?;
let key = VerifyingKey::from_bytes(&key).map_err(|_| refused())?;
let signature = Signature::from_slice(&a.signature).map_err(|_| refused())?;
key.verify(&device_ack_message(a), &signature).map_err(|_| refused())
}
struct ComponentState {
records: Vec<DeviceAcknowledgementTestOnly>,
state: Option<Vec<u8>>,
frozen: bool,
fault: DevicePowerLoss,
}
pub struct DeviceComponentTestOnly {
key: SigningKey,
clock: Arc<dyn V2AuthoritativeClock>,
capacity: usize,
state: Mutex<ComponentState>,
}
impl fmt::Debug for DeviceComponentTestOnly {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let (head, _, frozen) = self.head();
f.debug_struct("DeviceComponentTestOnly")
.field("head", &head)
.field("frozen", &frozen)
.field("capacity", &self.capacity)
.finish_non_exhaustive()
}
}
impl DeviceComponentTestOnly {
pub fn new(seed: &[u8], capacity: usize, clock: Arc<dyn V2AuthoritativeClock>) -> V2Result<Self> {
let seed: [u8; 32] = seed.try_into().map_err(|_| {
V2Error::new(
V2ErrorClass::ConfigurationInvalid,
"v2reference: device component needs a 32-byte seed, positive capacity, and a clock",
)
})?;
if capacity < 1 {
return Err(V2Error::new(
V2ErrorClass::ConfigurationInvalid,
"v2reference: device component needs a 32-byte seed, positive capacity, and a clock",
));
}
Ok(DeviceComponentTestOnly {
key: SigningKey::from_bytes(&seed),
clock,
capacity,
state: Mutex::new(ComponentState {
records: Vec::new(),
state: None,
frozen: false,
fault: DevicePowerLoss::Ok,
}),
})
}
fn lock(&self) -> MutexGuard<'_, ComponentState> {
self.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner())
}
pub fn public_key(&self) -> Vec<u8> {
self.key.verifying_key().to_bytes().to_vec()
}
pub fn set_power_loss(&self, fault: DevicePowerLoss) {
self.lock().fault = fault;
}
pub fn head(&self) -> (i64, Option<Vec<u8>>, bool) {
let s = self.lock();
(s.records.len() as i64, s.state.clone(), s.frozen)
}
pub fn provision_state(&self, digest: &[u8]) -> V2Result<()> {
let mut s = self.lock();
if s.state.is_some() || !s.records.is_empty() || digest.len() != 48 {
return Err(V2Error::plain(
"v2reference: device component is already provisioned or the digest is not 48 bytes",
));
}
s.state = Some(digest.to_vec());
Ok(())
}
pub fn anchor_state(&self, previous: &[u8], next: &[u8]) -> Result<(), DeviceErrorTestOnly> {
let mut s = self.lock();
if s.frozen {
return Err(DeviceErrorTestOnly::Frozen);
}
if s.state.as_deref() != Some(previous) || next.len() != 48 {
return Err(DeviceErrorTestOnly::StateMismatch);
}
s.state = Some(next.to_vec());
Ok(())
}
pub fn commit(
&self,
ctx: &V2Context,
log_id: &str,
sequence: i64,
previous_entry_hash: &[u8],
entry_hash: &[u8],
state: &[u8],
) -> Result<DeviceAcknowledgementTestOnly, DeviceErrorTestOnly> {
let now = self.clock.authoritative_time_v2(ctx);
self.commit_at(now, log_id, sequence, previous_entry_hash, entry_hash, state)
}
pub(crate) fn commit_at(
&self,
now: Result<i64, V2StoreError>,
log_id: &str,
sequence: i64,
previous_entry_hash: &[u8],
entry_hash: &[u8],
state: &[u8],
) -> Result<DeviceAcknowledgementTestOnly, DeviceErrorTestOnly> {
let mut s = self.lock();
if s.frozen {
return Err(DeviceErrorTestOnly::Frozen);
}
let acknowledged = s.records.len() as i64;
if sequence >= 1 && sequence <= acknowledged {
let existing = &s.records[sequence as usize - 1];
if existing.log_id == log_id && existing.entry_hash == entry_hash {
return Ok(existing.clone());
}
s.frozen = true;
return Err(DeviceErrorTestOnly::Frozen);
}
let mut head_entry = vec![0u8; 48];
if let Some(last) = s.records.last() {
if last.log_id != log_id {
return Err(DeviceErrorTestOnly::StateMismatch);
}
head_entry = last.entry_hash.clone();
}
if sequence != acknowledged + 1 || head_entry != previous_entry_hash || s.state.as_deref() != Some(state) {
return Err(DeviceErrorTestOnly::StateMismatch);
}
if s.records.len() >= self.capacity {
return Err(DeviceErrorTestOnly::StorageFull);
}
let fault = std::mem::take(&mut s.fault);
if fault == DevicePowerLoss::BeforeCommit {
return Err(DeviceErrorTestOnly::PowerLoss);
}
let now = now.map_err(DeviceErrorTestOnly::Store)?;
let mut ack = DeviceAcknowledgementTestOnly {
log_id: log_id.to_string(),
sequence,
entry_hash: entry_hash.to_vec(),
state_digest: state.to_vec(),
timestamp: now,
signature: Vec::new(),
};
ack.signature = self.key.sign(&device_ack_message(&ack)).to_bytes().to_vec();
s.records.push(ack.clone());
if fault == DevicePowerLoss::AfterCommit {
return Err(DeviceErrorTestOnly::PowerLoss);
}
Ok(ack)
}
pub fn get(&self, log_id: &str, sequence: i64) -> Result<DeviceAcknowledgementTestOnly, V2StoreError> {
let s = self.lock();
match s.records.get((sequence.max(1) - 1) as usize) {
Some(r) if sequence >= 1 && r.log_id == log_id => Ok(r.clone()),
_ => Err(V2StoreError::AcknowledgementNotFound),
}
}
}
impl Store {
pub fn corrupt_sealed_state_test_only(&self, claim_id: &str) {
if let Some(record) = self.lock().claims.get_mut(claim_id) {
if let Some(first) = record.terminal.first_mut() {
*first ^= 1;
}
}
}
pub(crate) fn appended_entry(&self, sequence: i64) -> Option<Vec<u8>> {
if sequence < 1 {
return None;
}
let s = self.lock();
s.outbox
.get(sequence as usize - 1)
.filter(|e| e.wire.is_some())
.map(|e| e.digest.clone())
}
fn appended_wire(&self, sequence: i64) -> Option<Vec<u8>> {
if sequence < 1 {
return None;
}
self.lock().outbox.get(sequence as usize - 1).and_then(|e| e.wire.clone())
}
fn log_id(&self) -> String {
self.lock().log_id.clone()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DeviceStartupStatus {
Ready,
PrimaryBehind,
StateDigestMismatch,
CheckpointFrozen,
}
impl DeviceStartupStatus {
pub fn as_str(self) -> &'static str {
match self {
DeviceStartupStatus::Ready => "ready",
DeviceStartupStatus::PrimaryBehind => "primary_behind",
DeviceStartupStatus::StateDigestMismatch => "state_digest_mismatch",
DeviceStartupStatus::CheckpointFrozen => "checkpoint_frozen",
}
}
}
pub struct DeviceCheckpointTestOnly {
device: Arc<PrimaryShared>,
primary: Arc<Store>,
component: Arc<DeviceComponentTestOnly>,
pinned: Vec<u8>,
}
impl fmt::Debug for DeviceCheckpointTestOnly {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DeviceCheckpointTestOnly")
.field("component", &self.component)
.finish_non_exhaustive()
}
}
impl DeviceCheckpointTestOnly {
pub fn new(
primary: &DevicePrimaryTestOnly,
component: Arc<DeviceComponentTestOnly>,
pinned: &[u8],
) -> V2Result<Self> {
primary.bind(Arc::clone(&component))?;
Ok(DeviceCheckpointTestOnly {
device: Arc::clone(&primary.shared),
primary: Arc::clone(&primary.store),
component,
pinned: pinned.to_vec(),
})
}
pub fn provision(&self) -> V2Result<()> {
let digest = self.device.complete_state_digest(&self.primary)?;
self.component.provision_state(&digest)
}
fn to_ack(&self, a: DeviceAcknowledgementTestOnly) -> Result<V2CheckpointAcknowledgement, DeviceErrorTestOnly> {
verify_device_acknowledgement_test_only(&self.pinned, &a)
.map_err(|e| DeviceErrorTestOnly::Store(V2StoreError::Unavailable(e)))?;
Ok(V2CheckpointAcknowledgement {
log_id: a.log_id,
sequence: a.sequence,
entry_hash: a.entry_hash,
timestamp: a.timestamp,
})
}
pub fn acknowledge(
&self,
ctx: &V2Context,
log_id: &str,
sequence: i64,
previous_entry_hash: &[u8],
entry_hash: &[u8],
) -> Result<V2CheckpointAcknowledgement, DeviceErrorTestOnly> {
if self.primary.appended_entry(sequence).as_deref() != Some(entry_hash) {
return Err(DeviceErrorTestOnly::NotAcknowledged);
}
let now = self.component.clock.authoritative_time_v2(ctx);
let ack = {
let anchor = self.device.lock_anchor();
let state = self
.device
.compose(&anchor.last_store)
.map_err(|e| DeviceErrorTestOnly::Store(V2StoreError::Classified(e)))?;
self.component
.commit_at(now, log_id, sequence, previous_entry_hash, entry_hash, &state)?
};
self.to_ack(ack)
}
pub fn submit_pending(&self, ctx: &V2Context) -> (Vec<i64>, Option<DeviceErrorTestOnly>) {
let mut acknowledged = Vec::new();
let log_id = self.primary.log_id();
let mut next = 1;
while let Some(entry) = self.primary.appended_entry(next) {
let already = matches!(self.component.get(&log_id, next), Ok(existing) if existing.entry_hash == entry);
if !already {
if let Err(e) = self.resubmit(ctx, next) {
return (acknowledged, Some(e));
}
acknowledged.push(next);
}
next += 1;
}
(acknowledged, None)
}
pub fn resubmit(&self, ctx: &V2Context, sequence: i64) -> Result<V2CheckpointAcknowledgement, DeviceErrorTestOnly> {
let entry = self
.primary
.appended_entry(sequence)
.ok_or(DeviceErrorTestOnly::NotAcknowledged)?;
let previous = if sequence > 1 {
self.primary
.appended_entry(sequence - 1)
.ok_or(DeviceErrorTestOnly::NotAcknowledged)?
} else {
vec![0u8; 48]
};
self.acknowledge(ctx, &self.primary.log_id(), sequence, &previous, &entry)
}
pub fn startup(&self) -> DeviceStartupStatus {
let (head, anchored, frozen) = self.component.head();
if frozen {
return DeviceStartupStatus::CheckpointFrozen;
}
if (self.primary.log_length() as i64) < head {
return DeviceStartupStatus::PrimaryBehind;
}
match self.device.complete_state_digest(&self.primary) {
Ok(state) if Some(&state) == anchored.as_ref() => DeviceStartupStatus::Ready,
_ => DeviceStartupStatus::StateDigestMismatch,
}
}
}
impl V2ReceiptCheckpoint for DeviceCheckpointTestOnly {
fn acknowledge_v2_receipt(
&self,
ctx: &V2Context,
log_id: &str,
sequence: i64,
previous_entry_hash: &[u8],
entry_hash: &[u8],
) -> Result<V2CheckpointAcknowledgement, V2StoreError> {
Ok(self.acknowledge(ctx, log_id, sequence, previous_entry_hash, entry_hash)?)
}
fn get_v2_acknowledgement(
&self,
_ctx: &V2Context,
log_id: &str,
sequence: i64,
) -> Result<V2CheckpointAcknowledgement, V2StoreError> {
let ack = self.component.get(log_id, sequence)?;
Ok(self.to_ack(ack)?)
}
}
#[derive(Debug)]
pub struct DeviceUplinkTestOnly {
device: Arc<DeviceCheckpointTestOnly>,
state: Mutex<(i64, Vec<Vec<u8>>)>,
}
impl DeviceUplinkTestOnly {
pub fn new(device: Arc<DeviceCheckpointTestOnly>) -> Self {
DeviceUplinkTestOnly {
device,
state: Mutex::new((0, Vec::new())),
}
}
pub fn upload(&self, _ctx: &V2Context) -> Vec<i64> {
let mut state = self.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
let (head, _, _) = self.device.component.head();
let mut sent = Vec::new();
while state.0 < head {
let next = state.0 + 1;
let Some(wire) = self.device.primary.appended_wire(next) else {
break;
};
state.1.push(wire);
state.0 = next;
sent.push(next);
}
sent
}
pub fn collected(&self) -> Vec<Vec<u8>> {
self.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner()).1.clone()
}
}