Struct Snapshot 

pub struct Snapshot<Data> {
    pub header: SnapshotHdr,
    pub data: Data,
}

Outer envelope wrapping a state blob.

Fields

header: SnapshotHdr

Header (magic + version).

data: Data

Wrapped state data.

Implementations

impl<Data> Snapshot<Data>

pub fn new(data: Data) -> Self

Construct a fresh envelope around data, stamped with this build’s magic + version.

pub fn version(&self) -> &Version

Borrow the embedded version.

impl<Data: Serialize> Snapshot<Data>

pub fn save<W: Write>(&self, writer: &mut W) -> Result<(), SnapshotError>

Save self into writer as bitcode(envelope) || crc64-le.

The CRC is computed over the bitcode bytes only (the trailing 8 bytes are not folded into the checksum) — same shape as upstream Firecracker so a firecracker --describe-snapshot succeeds.

Errors

SnapshotError::Bitcode for an encoding failure; SnapshotError::Io for a writer-side I/O failure.

impl<Data: DeserializeOwned> Snapshot<Data>

pub fn load<R: Read>(reader: &mut R) -> Result<Self, SnapshotError>

Load and validate the envelope from a Read.

Validates, in order:

1. Size is below the DoS-guard limit.
2. Trailing 8-byte CRC matches the body.
3. Magic equals the architecture-specific value.
4. Major version matches; minor version ≤ ours.

The “load_without_crc_check” variant is exposed for --describe-snapshot against a possibly-corrupt file: an operator wants to see the version even if the CRC has been clobbered, so the describe path can downgrade CRC errors to warnings.

Errors

SnapshotError::SizeLimitExceeded, SnapshotError::TooShort, SnapshotError::CrcMismatch, SnapshotError::MagicMismatch, SnapshotError::VersionMismatch, SnapshotError::Bitcode, SnapshotError::Io.

pub fn load_from_slice(buf: &[u8]) -> Result<Self, SnapshotError>

Load + validate from an in-memory slice. The slice must include the trailing 8-byte CRC.

Errors

Same as Self::load.

pub fn load_without_crc_check(data_buf: &[u8]) -> Result<Self, SnapshotError>

Decode the envelope without checking the CRC.

Used by --describe-snapshot to emit a useful diagnostic on a CRC-clobbered file (the version + magic are still meaningful). Production load paths must go through Self::load / Self::load_from_slice which validate the CRC first.

Errors

SnapshotError::SizeLimitExceeded, SnapshotError::Bitcode, SnapshotError::MagicMismatch, SnapshotError::VersionMismatch.

Trait Implementations

impl<Data: Clone> Clone for Snapshot<Data>

fn clone(&self) -> Snapshot<Data>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Data: Debug> Debug for Snapshot<Data>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, Data> Deserialize<'de> for Snapshot<Data>

where Data: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Data: PartialEq> PartialEq for Snapshot<Data>

fn eq(&self, other: &Snapshot<Data>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Data> Serialize for Snapshot<Data>

where Data: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Data> StructuralPartialEq for Snapshot<Data>