Struct vm_control::snapshot_format::SnapshotWriter

pub struct SnapshotWriter {
    dir: PathBuf,
    key: Option<CryptKey>,
}

Writer of serialized VM snapshots.

Each fragment is an opaque byte blob. Namespaces can be used to avoid fragment naming collisions between devices.

In the current implementation, fragments are files and namespaces are directories, but the API is kept abstract so that we can potentially support something like a single file archive output.

Fields

dir: PathBuf

key: Option<CryptKey>

If encryption is used, the plaintext key will be stored here.

Implementations

impl SnapshotWriter

pub fn new(root: PathBuf, encrypt: bool) -> Result<Self>

Creates a new SnapshotWriter that will writes its data to a dir at root. The path must not exist yet. If encryption is desired, set encrypt (Note: only supported downstream on Windows).

pub fn raw_fragment(&self, name: &str) -> Result<Box<dyn Write>>

Creates a snapshot fragment and get access to the Write impl representing it.

pub fn raw_fragment_with_chunk_size( &self, name: &str, chunk_size_bytes: usize ) -> Result<Box<dyn Write>>

When encryption is used, allows direct control of the encrypted chunk size.

pub fn write_fragment<T: Serialize>(&self, name: &str, v: &T) -> Result<()>

Creates a snapshot fragment from a serialized representation of v.

pub fn add_namespace(&self, name: &str) -> Result<Self>

Creates new namespace and returns a SnapshotWriter that writes to it. Namespaces can be nested.

Trait Implementations

impl Clone for SnapshotWriter

fn clone(&self) -> SnapshotWriter

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SnapshotWriter

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SnapshotWriter

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SnapshotWriter

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

where __S: Serializer,

Serialize this value into the given Serde serializer.