use serde::{Deserialize, Serialize};
#[cfg(feature = "wincode")]
use wincode_derive::{SchemaRead, SchemaWrite};
use crate::erasure::GROUP_SIZE;
use crate::types::EpochNumber;
use tape_crypto::Address;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "wincode", derive(SchemaRead, SchemaWrite))]
#[derive(Default)]
pub enum NodeStatus {
#[default]
Standby,
Active,
RecoverMetadata,
RecoveryReplay,
RecoveryInProgress { epoch: EpochNumber },
PartialReplay {
first_complete_epoch: EpochNumber,
epoch_at_start: EpochNumber,
},
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "wincode", derive(SchemaRead, SchemaWrite))]
pub enum SpoolStatus {
Active,
Sync,
Scan,
Repair,
Recover,
LockedToMove,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "wincode", derive(SchemaRead, SchemaWrite))]
pub struct SpoolState {
pub status: SpoolStatus,
pub epoch: EpochNumber,
pub prev_owner: Option<Address>,
pub prev_helpers: [Option<Address>; GROUP_SIZE],
}
impl SpoolState {
pub fn new(status: SpoolStatus, epoch: EpochNumber) -> Self {
Self {
status,
epoch,
prev_owner: None,
prev_helpers: [None; GROUP_SIZE],
}
}
pub fn set_status(&mut self, status: SpoolStatus) {
self.status = status;
}
pub fn set_epoch(&mut self, epoch: EpochNumber) {
self.epoch = epoch;
}
pub fn is_locked(&self) -> bool { self.status == SpoolStatus::LockedToMove }
pub fn is_active(&self) -> bool { self.status == SpoolStatus::Active }
pub fn is_syncing(&self) -> bool { self.status == SpoolStatus::Sync }
pub fn is_scanning(&self) -> bool { self.status == SpoolStatus::Scan }
pub fn is_recovering(&self) -> bool { self.status == SpoolStatus::Recover }
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn node_status_default() {
assert_eq!(NodeStatus::default(), NodeStatus::Standby);
}
#[cfg(feature = "wincode")]
#[test]
fn spool_state_roundtrip() {
let owner = Address::new([7u8; 32]);
let helper = Address::new([3u8; 32]);
let states = vec![
SpoolState::new(SpoolStatus::Active, EpochNumber(0)),
SpoolState::new(SpoolStatus::LockedToMove, EpochNumber(42)),
SpoolState {
status: SpoolStatus::Sync,
epoch: EpochNumber(5),
prev_owner: Some(owner),
prev_helpers: [Some(owner); GROUP_SIZE],
},
SpoolState::new(SpoolStatus::Scan, EpochNumber(6)),
SpoolState {
status: SpoolStatus::Recover,
epoch: EpochNumber(7),
prev_owner: Some(helper),
prev_helpers: [None; GROUP_SIZE],
},
];
for state in states {
let bytes = wincode::serialize(&state).unwrap();
let decoded: SpoolState = wincode::deserialize(&bytes).unwrap();
assert_eq!(state, decoded);
}
}
#[cfg(feature = "wincode")]
#[test]
fn node_status_roundtrip() {
let statuses = vec![
NodeStatus::Standby,
NodeStatus::Active,
NodeStatus::RecoverMetadata,
NodeStatus::RecoveryReplay,
NodeStatus::RecoveryInProgress {
epoch: EpochNumber(42),
},
NodeStatus::PartialReplay {
first_complete_epoch: EpochNumber(10),
epoch_at_start: EpochNumber(5),
},
];
for status in statuses {
let bytes = wincode::serialize(&status).unwrap();
let decoded: NodeStatus = wincode::deserialize(&bytes).unwrap();
assert_eq!(status, decoded);
}
}
}