Go SDK Snapshots reference

See the snapshot guide for workflows and examples. Use snapshot objects or references on cloud. Local operations also accept a group head, group:member, or artifact path.

Guest writeback

Set SnapshotCreateOptions.GuestFlush to msb.GuestFlushRequired, pass msb.WithForkGuestFlush(msb.GuestFlushRequired) to Fork/ForkMany, or call source.PauseWithGuestFlush(ctx, msb.GuestFlushRequired). The default GuestFlushAuto flushes live disk-only captures, but adds no optional flush to full captures, forks, or pause. GuestFlushSkip retains mandatory storage barriers. A paused disk capture needs a matching prior flush; cloud rejects non-Auto policies. See guest flush policy reference. Disk capture, including SandboxHandle.Snapshot, requires a native library that supports guest-flush policies. Older libraries return an upgrade-required error, including for stopped disk captures. Full Auto capture and unrelated operations retain their compatibility.

Snapshot functions

Package-level helpers for snapshot artifacts. Access them through the exported Snapshot value, e.g. m.Snapshot.Create(ctx, ...).

Snapshot.Create()

func (snapshotFactory) Create(ctx context.Context, opts SnapshotCreateOptions) (*SnapshotArtifact, error)

Create a disk snapshot, or set Full to include memory and execution state. SnapshotCreateOptions.FromSandbox is required. An empty Name is generated; an empty Group uses the source sandbox’s name.

Parameters

ctxcontext.Context

Cancellation and deadline.

optsSnapshotCreateOptions

Name, source sandbox, labels, and integrity options.

Returns

*SnapshotArtifact

The created local or cloud snapshot.

Example

snap, err := m.Snapshot.Create(ctx, m.SnapshotCreateOptions{
    Name:            "deps",
    FromSandbox:     "baseline",
    Labels:          map[string]string{"stage": "post-deps"},
    RecordIntegrity: true,
})

Snapshot.CreateArchive()

func (snapshotFactory) CreateArchive(ctx context.Context, opts SnapshotArchiveOptions) (*SnapshotArchive, error)

Capture directly into an archive without installing a local snapshot.

Example

archive, err := m.Snapshot.CreateArchive(ctx, m.SnapshotArchiveOptions{
    SnapshotCreateOptions: m.SnapshotCreateOptions{
        Name:        "deps",
        FromSandbox: "baseline",
    },
    ArchivePath: "/tmp/deps.msb",
})

Snapshot.Open()

func (snapshotFactory) Open(ctx context.Context, pathOrName string) (*SnapshotArtifact, error)

Example

snap, err := m.Snapshot.Open(ctx, "baseline:deps")

Open an existing artifact by group head, group:member, or filesystem path. This validates metadata only; call s.Verify() for content checks.

Parameters

ctxcontext.Context

Cancellation and deadline.

pathOrNamestring

Group head or group:member selector or artifact directory path.

Returns

*SnapshotArtifact

The opened local or cloud snapshot.

Snapshot.Get()

func (snapshotFactory) Get(ctx context.Context, nameOrDigest string) (*SnapshotHandle, error)

Example

h, err := m.Snapshot.Get(ctx, "baseline:deps")

Look up a lightweight handle by group head, group:member, stable snapshot ID, descriptor digest, or artifact path. Global IDs and digests must resolve unambiguously.

Parameters

ctxcontext.Context

Cancellation and deadline.

nameOrDigeststring

Group head, group:member, stable snapshot ID, digest, or artifact path.

Returns

*SnapshotHandle

Lightweight handle returned by the active backend.

Snapshot.List()

func (snapshotFactory) List(ctx context.Context) ([]*SnapshotHandle, error)

Example

handles, err := m.Snapshot.List(ctx)
for _, h := range handles {
    fmt.Println(h.Digest(), h.ImageRef())
}

List snapshots visible through the active backend. Cloud lists managed snapshots; host-volume artifacts are opened explicitly by reference.

Returns

[]*SnapshotHandle

All indexed handles.

Snapshot.ListDir()

func (snapshotFactory) ListDir(ctx context.Context, dir string) ([]*SnapshotArtifact, error)

Walk a local directory and parse each subdirectory’s manifest without touching the local index. Cloud returns ErrUnsupportedOperation.

Parameters

ctxcontext.Context

Cancellation and deadline.

dirstring

Directory holding snapshot artifact subdirectories.

Returns

[]*SnapshotArtifact

One artifact per parsed subdirectory.

Snapshot.Remove()

func (snapshotFactory) Remove(ctx context.Context, pathOrName string, force bool) error

Example

err := m.Snapshot.Remove(ctx, "baseline:deps", false)

Remove a snapshot through the active backend. Locally, removal also updates the index and refuses indexed children unless force is true.

Parameters

ctxcontext.Context

Cancellation and deadline.

pathOrNamestring

Group head, group:member, or artifact path.

forcebool

Delete even if the snapshot has indexed children.

Snapshot.Reindex()

func (snapshotFactory) Reindex(ctx context.Context, dir string) (uint32, error)

Example

n, err := m.Snapshot.Reindex(ctx, "/srv/snapshots")
fmt.Printf("indexed %d snapshots\n", n)

Walk dir and rebuild the local index from the artifacts it finds. Cloud returns ErrUnsupportedOperation.

Parameters

ctxcontext.Context

Cancellation and deadline.

dirstring

Directory to scan for snapshot artifacts.

Returns

uint32

Number of artifacts indexed.

Snapshot.Save()

function

func (snapshotFactory) Save(ctx context.Context, nameOrPath, outPath string, opts SnapshotSaveOptions) error

Bundle a snapshot into a .msb archive at outPath. Set SnapshotSaveOptions.PlainTar to skip compression.

Parameters

ctxcontext.Context

Cancellation and deadline.

nameOrPathstring

Group head, group:member, or artifact path to save.

outPathstring

Destination archive path.

optsSnapshotSaveOptions

Whether to include parents, the base image, and compression.

Example

err := m.Snapshot.Save(ctx, "baseline:deps", "/tmp/snap.msb",
    m.SnapshotSaveOptions{WithParents: true},
)

Snapshot.Load()

function

func (snapshotFactory) Load(ctx context.Context, archive, dest string) (*SnapshotHandle, error)

Unpack a snapshot archive into the local snapshots directory or an explicit dest directory. Pass "" for the default destination. Cloud returns ErrUnsupportedOperation.

Parameters

ctxcontext.Context

Cancellation and deadline.

archivestring

Path to the snapshot archive.

deststring

Destination directory, or "" for the default snapshots directory.

Returns

*SnapshotHandle

Handle to the loaded snapshot.

Example

h, err := m.Snapshot.Load(ctx, "/tmp/snap.msb", "")

Snapshot.LoadWithBase()

func (snapshotFactory) LoadWithBase(
    ctx context.Context, archive, dest, base string,
) (*SnapshotHandle, error)

Import an archive with an explicit dependency base or destination group. See import options.

Snapshot.LoadWithOptions()

func (snapshotFactory) LoadWithOptions(
    ctx context.Context, archive string, opts SnapshotLoadOptions,
) (*SnapshotHandle, error)

Import an archive with an explicit dependency base or destination group. See import options.

Snapshot.LoadMany()

func (snapshotFactory) LoadMany(
    ctx context.Context, archives []string, opts SnapshotLoadOptions,
) ([]*SnapshotHandle, error)

Import archives as one batch. Returns handles in input order. Dependencies resolve from the batch, the named group, or an explicit base; input order does not matter. All members are validated before publication.

Snapshot.GroupHead()

func (snapshotFactory) GroupHead(
    ctx context.Context, selector string,
) (*SnapshotHeadUpdate, error)

Read a group’s head, or select an exact member with group:member. Returns the group, previous and current snapshot IDs, reason, and whether the head changed. See group selection.

Import options

Options for SnapshotLoadOptions.

Option	Purpose
`Dest`	Parent directory containing groups. Defaults to the local snapshot store.
`Base`	External snapshot or standalone archive for missing dependencies.
`Group`	Destination group. Omit to create one group for the import.
`SetHead`	Select the imported tip, even with divergent ancestry. Defaults to false; requires a unique tip.

With divergent tips, the existing head stays selected; a new group has no head. Select a member explicitly. Identical members may be reused; conflicting identities fail. See archive imports.

SandboxHandle methods

Snapshots are taken from a metadata handle returned by GetSandbox. Local disk capture also supports a running or paused sandbox. Cloud requires a stopped persistent source.

_ = sb.Stop(ctx)
_ = sb.Close()

h, err := m.GetSandbox(ctx, "baseline")
if err != nil {
    return err
}
snap, err := h.Snapshot(ctx, "deps")

h.Snapshot()

func (h *SandboxHandle) Snapshot(ctx context.Context, name string) (*SnapshotArtifact, error)

Snapshot this sandbox into its default group with the given member name. Local live disk captures preserve the source’s running or paused state. Cloud requires a stopped persistent source. Use the returned artifact path or sandbox:member to open it later.

Parameters

ctxcontext.Context

Cancellation and deadline.

namestring

Member name within the source sandbox’s group.

Returns

*SnapshotArtifact

The created artifact.

Example

snap, err := h.Snapshot(ctx, "deps")

SnapshotArtifact methods

A local or cloud disk snapshot. The accessors below are plain field reads.

s.SaveTo()

func (s *SnapshotArtifact) SaveTo(
    ctx context.Context,
    outPath string,
    opts SnapshotSaveOptions,
) error

Bundle this snapshot through the active backend while preserving its typed identifier-or-path reference. Cloud returns ErrUnsupportedOperation.

err := snap.SaveTo(ctx, "/tmp/snap.tar.zst", m.SnapshotSaveOptions{
    WithImage: true,
})

s.CopyTo()

func (s *SnapshotArtifact) CopyTo(outputArchivePath string) *SnapshotCopyBuilder

Create a new archive from this snapshot’s disk data while replacing its labels and integrity metadata. The source snapshot is unchanged. Cloud returns ErrUnsupportedOperation when Save is called.

err := snap.CopyTo("/tmp/snap-copy.tar.zst").
    Labels(map[string]string{"environment": "test"}).
    RecordIntegrity(true).
    Save(ctx)

s.ID()

func (s *SnapshotArtifact) ID() string

Stable opaque snap_... identity.

s.Verify()

func (s *SnapshotArtifact) Verify(ctx context.Context) (*SnapshotVerifyReport, error)

Verify the snapshot’s complete state closure. File state recomputes recorded upper-layer integrity. Checkpoint state validates the complete checkpoint closure and returns its root in Checkpoint.

Returns

*SnapshotVerifyReport

Recomputed digest and upper-layer status.

Example

report, err := snap.Verify(ctx)
if err != nil {
    return err
}
if report.Upper.Kind == "not_recorded" {
    fmt.Println("snapshot has no recorded payload integrity")
} else {
    fmt.Println(report.Upper.Digest)
}

s.Reference()

func (s *SnapshotArtifact) Reference() string

Stable backend-relative value. Prefer passing the SnapshotArtifact itself to RestoreSandbox so its typed reference is preserved as well.

s.ReferenceKind()

func (s *SnapshotArtifact) ReferenceKind() string

Returns "id" or "path". Most callers can pass the artifact itself and never inspect this value.

s.Digest()

func (s *SnapshotArtifact) Digest() string

Canonical manifest digest (sha256:...).

s.SizeBytes()

func (s *SnapshotArtifact) SizeBytes() *uint64

Backend-reported stored payload size in bytes.

s.ImageRef()

func (s *SnapshotArtifact) ImageRef() string

Image reference the snapshot was taken from.

s.ImageManifestDigest()

func (s *SnapshotArtifact) ImageManifestDigest() string

Pinned OCI manifest digest of the base image.

s.Format()

func (s *SnapshotArtifact) Format() string

Upper-layer disk format: "raw" or "qcow2".

s.Scope()

method

func (s *SnapshotArtifact) Scope() string

Snapshot scope: SnapshotScopeDisk ("disk") or SnapshotScopeFull ("full").

s.Fstype()

func (s *SnapshotArtifact) Fstype() string

Filesystem type inside the upper layer.

s.Parent()

func (s *SnapshotArtifact) Parent() *string

Parent digest, or nil if this snapshot has no parent. Returns a defensive copy.

s.CreatedAt()

func (s *SnapshotArtifact) CreatedAt() string

RFC 3339 creation timestamp.

s.Labels()

func (s *SnapshotArtifact) Labels() map[string]string

User labels recorded at creation. Returns a defensive copy.

s.SourceSandbox()

func (s *SnapshotArtifact) SourceSandbox() *string

Best-effort source sandbox name, or nil. Returns a defensive copy.

SnapshotHandle methods

A lightweight handle returned by the active backend. The handle retains a stable reference used by Open, Remove, and SaveTo.

h.Open()

func (h *SnapshotHandle) Open(ctx context.Context) (*SnapshotArtifact, error)

Example

snap, err := h.Open(ctx)

Open the underlying snapshot metadata using this handle’s stable reference.

Returns

*SnapshotArtifact

The opened artifact.

h.Remove()

func (h *SnapshotHandle) Remove(ctx context.Context, force bool) error

Example

err := h.Remove(ctx, false)

Remove this installed snapshot copy by its stored artifact path. Other groups containing the same snapshot ID or digest remain unchanged.

Parameters

ctxcontext.Context

Cancellation and deadline.

forcebool

Delete even if the snapshot has indexed children.

h.SaveTo()

func (h *SnapshotHandle) SaveTo(
    ctx context.Context,
    outPath string,
    opts SnapshotSaveOptions,
) error

Bundle the referenced snapshot through the active backend while preserving the handle’s typed identifier-or-path reference. Cloud returns ErrUnsupportedOperation.

h.Digest()

func (h *SnapshotHandle) Digest() string

Manifest digest.

h.Name()

func (h *SnapshotHandle) Name() *string

Member name within its group, or nil when no alias is recorded. Returns a defensive copy.

h.ParentDigest()

func (h *SnapshotHandle) ParentDigest() *string

Parent digest, or nil. Returns a defensive copy.

h.ImageRef()

func (h *SnapshotHandle) ImageRef() string

Pinned image reference.

h.Format()

func (h *SnapshotHandle) Format() string

Upper-layer disk format: "raw" or "qcow2".

h.Scope()

method

func (h *SnapshotHandle) Scope() string

Snapshot scope: SnapshotScopeDisk ("disk") or SnapshotScopeFull ("full").

h.SizeBytes()

func (h *SnapshotHandle) SizeBytes() *uint64

Backend-reported stored payload size, or nil if unknown.

h.ReferenceKind()

func (h *SnapshotHandle) ReferenceKind() string

Returns "id" or "path" for the handle’s backend-neutral reference.

h.CreatedAt()

func (h *SnapshotHandle) CreatedAt() time.Time

Snapshot creation time, decoded from the index’s Unix timestamp.

Forking

Fork a running or paused local sandbox to create a child with copy-on-write memory. The source returns to its previous state, and each child needs an unused name. SandboxHandle has the same methods. See the forking guide for backend limits and disk bindings.

Fork

func (s *Sandbox) Fork(ctx context.Context, name string, opts ...ForkOption) (*Sandbox, error)

Example

child, err := sb.Fork(ctx, "experiment")
if err != nil {
    return err
}
defer child.Close()
defer child.Stop(context.Background())

Create one child from the current execution state.

ForkMany

func (s *Sandbox) ForkMany(ctx context.Context, names []string, opts ...ForkOption) ([]ForkOutcome, error)

Example

outcomes, err := sb.ForkMany(ctx, []string{"alice", "bob"})
if err != nil {
    return err
}
for _, outcome := range outcomes {
    if outcome.Error != nil {
        log.Printf("%s: %v", outcome.Name, outcome.Error)
        continue
    }
    defer outcome.Sandbox.Close()
    if err := outcome.Sandbox.Stop(ctx); err != nil {
        return err
    }
}

Capture once for all names and return outcomes in input order. Each outcome has Name, plus a started Sandbox or an Error; the other field is nil. Validation or capture errors return for the whole call; a child startup error leaves successful siblings running. Stop and close successful children when finished. Use WithForkIntegrity() to record disk hashes, WithForkGuestFlush(GuestFlushRequired) to request guest writeback, and WithForkVolumes to rebind captured disks. Forks cannot add new block devices, and batch children cannot share a writable disk image. See fork disk bindings. The Branch names remain deprecated aliases; use fork option functions in place of the removed ForkOptions and BranchOptions structs.

Restore

Restore into a new detached sandbox. Disk boots fresh; full resumes execution. See restore examples and progress.

Example

child, err := m.RestoreSandbox(ctx, "api:baseline", "api-restored", m.WithCowMemory())

Control	Purpose
`WithCowMemory()`	Share unchanged full-snapshot memory.
`WithForked() / RestoreConfig.Forked`	Deprecated alias for the same CoW memory policy; see migration notes.
`WithSnapshotDiskOnly()`	Boot only the saved disk.
`WithSnapshotBase(base)`	Supply an archive dependency.
`RestoreSandbox`	Return the restored sandbox.
`RestoreSandboxWithProgress`	Return event and result channels.

Image, replacement, and startup-command options are not accepted. Full restore requires matching CPU and memory settings, keeps captured network devices, and cannot apply a new guest security profile. Use disk-only restore to change these. Restore rejects missing external filesystems (and, for full restore, additional disks) by default. Use WithAllowMissingResources() to resume with unavailable devices (full restore records warnings). This is separate from strict/relaxed validation of supplied mappings; inheritance does not waive missing backing. Root and owned storage remain required.

Destination options

Option	Purpose
`WithRestoreCPUs, WithRestoreMemory`	CPU count and memory in MiB. Full restore must match capture.
`WithRestoreNetworkPolicy`	Replace host traffic filtering; guest DNS and TLS settings stay unchanged.
`WithRestoreMaxConnections`	Concurrent TCP limit; zero means unlimited.
`WithRestoreDisableNetwork`	Remove the NIC. Rejected for full snapshots that captured one.
`WithRestoreSecurityProfile`	Guest security profile. Disk boot only, including an explicit default profile.
`WithRestoreMaxDuration, WithRestoreIdleTimeout`	Lifetime and idle limits. Omitted means unlimited; zero expires immediately.
`Ports`	Bind destination TCP or UDP ports.
`Vsock`	Bind destination vsock endpoints.
`User, LogLevel`	Default user for new execs and host runtime log level.
`WithDangerouslyInheritResources`	Explicitly inherit host resources. Disabled by default.
`WithExternalMountPolicy`	Validate supplied filesystem mappings: strict (default) or relaxed. Does not grant access.

Omitted controls retain destination defaults. Durations use time.Duration, rounded up to seconds. Binding fields belong in WithRestoreConfig(RestoreConfig{...}); nil pointers mean omitted. Network policy accepts factory results or NetworkConfig with only Rules, DefaultEgress, and DefaultIngress.

RestoreConfig.Volumes

Volumes map[string]MountConfig

Map host volumes to guest paths. Pass the configuration through WithRestoreConfig().

Example

child, err := m.RestoreSandbox(ctx, "api:baseline", "api-restored",
    m.WithRestoreConfig(m.RestoreConfig{
        Volumes: map[string]m.MountConfig{
            "/data": m.Mount.Disk("./seed.img", m.DiskOptions{Fstype: "ext4"}),
        },
    }),
)

RestoreConfig.CapturedVolumes

CapturedVolumes []string

Select captured private volumes by guest path. Pass the configuration through WithRestoreConfig().

WithAllowMissingResources()

func WithAllowMissingResources() RestoreOption

Allow unavailable external filesystems or additional disks. Full restore records warnings; root and owned storage remain required. Disabled by default. This does not relax validation of supplied mappings.

Compaction

Compact a local sandbox’s root or owned disks. See compaction for examples and recovery requirements.

Options and results

Option	Purpose
`Disk`	Select one owned disk by guest path; `/` selects the root.
`RootDiskOnly`	Select only the root. Cannot combine with the disk selector.
`Layers`	Oldest sealed layers to merge, including the base. Minimum two; omit for all. Excludes the writable layer.
`DryRun`	Preview without changing storage.

Defaults to the root and owned data disks; excludes named/external volumes and directories. Requires a running or fully stopped local sandbox. Fewer than two sealed layers means no change; no eligible disks returns an empty result with zero counts.Results include aggregate counts and per-disk entries keyed by GuestPath. MaterializedBytes counts copied bytes, not reclaimed space. Times are microseconds: per-disk TotalUs covers preparation; aggregate TotalUs also includes switching; PauseUs measures the shared VM pause.

Constants

Snapshot scopes

Returned by s.Scope() · h.Scope()

Scope of what a snapshot captures: disk-only or disk plus complete VM state.

Constant	Value	Description
`SnapshotScopeDisk`	`"disk"`	Disk-only snapshot
`SnapshotScopeFull`	`"full"`	Disk plus complete VM execution state

Types

SnapshotArtifactstruct

Returned by Snapshot.Create() · Snapshot.Open() · Snapshot.ListDir() · h.Snapshot() · h.Open()

A backend-neutral snapshot. Fields are unexported; read them through the accessor methods below.

Method	Returns	Description
`ID()`	`string`	Stable opaque snapshot identity
`Path()`	`string`	Local artifact directory; panics on cloud
`Reference()`	`string`	Stable backend-relative restore reference
`ReferenceKind()`	`string`	`id` or `path`
`Digest()`	`string`	Canonical manifest digest (`sha256:...`)
`SizeBytes()`	`*uint64`	Backend-reported stored payload size, when known
`ImageRef()`	`string`	Image reference the snapshot was taken from
`ImageManifestDigest()`	`string`	Pinned OCI manifest digest
`Format()`	`string`	`"raw"` or `"qcow2"`
`Scope()`	`string`	`SnapshotScopeDisk` or `SnapshotScopeFull`
`Fstype()`	`string`	Filesystem type inside the upper layer
`Parent()`	`*string`	Parent digest, or nil
`CreatedAt()`	`string`	RFC 3339 timestamp
`Labels()`	`map[string]string`	User labels
`SourceSandbox()`	`*string`	Best-effort source sandbox name
`SaveTo(ctx, outPath, opts)`	`error`	Bundle using this snapshot’s typed reference
`CopyTo(outputArchivePath)`	`*SnapshotCopyBuilder`	Configure a copied archive with replacement metadata
`Verify(ctx)`	`(*SnapshotVerifyReport, error)`	Recompute content integrity

SnapshotCopyBuilderstruct

Returned by SnapshotArtifact.CopyTo. Fields are unexported; use the fluent methods below.

Method	Returns	Description
`Labels(map[string]string)`	`*SnapshotCopyBuilder`	Replace all labels in the copied manifest
`RecordIntegrity(bool)`	`*SnapshotCopyBuilder`	Compute integrity when true, or omit it when false
`Save(context.Context)`	`error`	Write the configured archive

SnapshotHandlestruct

Returned by Snapshot.Get() · Snapshot.List() · Snapshot.Load()

A lightweight handle returned by the active backend. Fields are unexported; read them through the accessor methods below.

Method	Returns	Description
`ID()`	`string`	Stable opaque snapshot identity
`Path()`	`string`	Local artifact directory; panics on cloud
`Digest()`	`string`	Manifest digest
`Name()`	`*string`	Bare-name alias, if indexed with one
`ParentDigest()`	`*string`	Parent digest, or nil
`ImageRef()`	`string`	Pinned image reference
`Format()`	`string`	`"raw"` or `"qcow2"`
`Scope()`	`string`	`SnapshotScopeDisk` or `SnapshotScopeFull`
`SizeBytes()`	`*uint64`	Backend-reported stored payload size
`Reference()`	`string`	Stable backend-relative restore reference
`ReferenceKind()`	`string`	`id` or `path`
`CreatedAt()`	`time.Time`	Snapshot creation time
`Open(ctx)`	`(*SnapshotArtifact, error)`	Open the artifact metadata
`Remove(ctx, force)`	`error`	Remove this snapshot
`SaveTo(ctx, outPath, opts)`	`error`	Bundle using this handle’s typed reference

SnapshotCreateOptionsstruct

Accepted by Snapshot.Create()

Configures Snapshot.Create. FromSandbox is required. An empty Name is generated; an empty Group uses the source sandbox’s name.

Name

string Member name within its group; generated when empty

Group

string Destination snapshot group; defaults to the source sandbox’s name

FromSandbox

string Name of the source sandbox; local disk capture supports running, paused, stopped, and crashed sources. Cloud requires a stopped persistent source

DestDir

string Parent directory containing snapshot groups; empty = the default snapshots directory

Labels

map[string]string Arbitrary user labels recorded in the manifest

Force

bool Overwrite a direct archive output; rejected for installed group members

RecordIntegrity

bool Record content hashes so Verify can recompute them later

Full

bool Local-only when true: include memory and execution state from a running or paused source. With false, local disk capture supports running, paused, stopped, or crashed sources. Cloud requires false and a stopped persistent source

GuestFlush

GuestFlush Guest writeback policy; defaults to GuestFlushAuto. See guest writeback

SnapshotSaveOptionsstruct

Accepted by Snapshot.Save() and instance SaveTo() methods

Configures Snapshot.Save and instance SaveTo() methods.

Field	Type	Description
Since	`string`	Omit disk layers and RAM objects supplied by an exact base; incompatible with `LastLayers` and `WithParents`
LastLayers	`*uint32`	Include the newest N sealed root-disk layers; owned disks and full execution state remain complete
WithParents	`bool`	Include the snapshot’s parent chain in the archive
WithImage	`bool`	Include the base OCI image in the archive
PlainTar	`bool`	Write an uncompressed `.tar` instead of `.msb`

SnapshotVerifyReportstruct

Returned by s.Verify()

Result of Verify.

Field	Type	Description
Digest	`string`	Recomputed manifest digest
Path	`string`	Artifact directory that was verified
Upper	`SnapshotUpperVerifyStatus`	Upper-layer integrity status
Checkpoint	`*SnapshotCheckpointVerifyStatus`	Verified checkpoint root for full state; otherwise `nil`

SnapshotUpperVerifyStatusstruct

Field of SnapshotVerifyReport

Upper-layer integrity details inside a SnapshotVerifyReport.

Field	Type	Description
Kind	`string`	Integrity record kind
Algorithm	`string`	Hash algorithm used
Digest	`string`	Recomputed upper-layer digest

​Guest writeback

​Snapshot functions

​Snapshot.Create()

​Snapshot.CreateArchive()

​Snapshot.Open()

​Snapshot.Get()

​Snapshot.List()

​Snapshot.ListDir()

​Snapshot.Remove()

​Snapshot.Reindex()

​Snapshot.Save()

​Snapshot.Load()

​Snapshot.LoadWithBase()

​Snapshot.LoadWithOptions()

​Snapshot.LoadMany()

​Snapshot.GroupHead()

​Import options

​SandboxHandle methods

​h.Snapshot()

​SnapshotArtifact methods

​s.SaveTo()

​s.CopyTo()

​s.ID()

​s.Verify()

​s.Reference()

​s.ReferenceKind()

​s.Digest()

​s.SizeBytes()

​s.ImageRef()

​s.ImageManifestDigest()

​s.Format()

​s.Scope()

​s.Fstype()

​s.Parent()

​s.CreatedAt()

​s.Labels()

​s.SourceSandbox()

​SnapshotHandle methods

​h.Open()

​h.Remove()

​h.SaveTo()

​h.Digest()

​h.Name()

​h.ParentDigest()

​h.ImageRef()

​h.Format()

​h.Scope()

​h.SizeBytes()

​h.ReferenceKind()

​h.CreatedAt()

​Forking

​Fork

​ForkMany

​Restore

​RestoreConfig.Volumes

​RestoreConfig.CapturedVolumes

​WithAllowMissingResources()

​Compaction

​Constants

​Types

​SnapshotArtifactstruct

​SnapshotCopyBuilderstruct

​SnapshotHandlestruct

​SnapshotCreateOptionsstruct

​Name

​Group

​FromSandbox

​DestDir

​Labels

​Force

​RecordIntegrity

​Full

​GuestFlush

​SnapshotSaveOptionsstruct

​SnapshotVerifyReportstruct

​SnapshotUpperVerifyStatusstruct

Guest writeback

Snapshot functions

Snapshot.Create()

Snapshot.CreateArchive()

Snapshot.Open()

Snapshot.Get()

Snapshot.List()

Snapshot.ListDir()

Snapshot.Remove()

Snapshot.Reindex()

Snapshot.Save()

Snapshot.Load()

Snapshot.LoadWithBase()

Snapshot.LoadWithOptions()

Snapshot.LoadMany()

Snapshot.GroupHead()

Import options

SandboxHandle methods

h.Snapshot()

SnapshotArtifact methods

s.SaveTo()

s.CopyTo()

s.ID()

s.Verify()

s.Reference()

s.ReferenceKind()

s.Digest()

s.SizeBytes()

s.ImageRef()

s.ImageManifestDigest()

s.Format()

s.Scope()

s.Fstype()

s.Parent()

s.CreatedAt()

s.Labels()

s.SourceSandbox()

SnapshotHandle methods

h.Open()

h.Remove()

h.SaveTo()

h.Digest()

h.Name()

h.ParentDigest()

h.ImageRef()

h.Format()

h.Scope()

h.SizeBytes()

h.ReferenceKind()

h.CreatedAt()

Forking

Fork

ForkMany

Restore

RestoreConfig.Volumes

RestoreConfig.CapturedVolumes

WithAllowMissingResources()

Compaction

Constants

Types

SnapshotArtifactstruct

SnapshotCopyBuilderstruct

SnapshotHandlestruct

SnapshotCreateOptionsstruct

Name

Group

FromSandbox

DestDir

Labels

Force

RecordIntegrity

Full

GuestFlush

SnapshotSaveOptionsstruct

SnapshotVerifyReportstruct

SnapshotUpperVerifyStatusstruct