Enum Command 

pub(crate) enum Command {
    Init {
        algorithm: Algorithm,
        path: Option<PathBuf>,
        insecure: bool,
        reset_metadata: bool,
    },
    Transaction,
    Cat {
        name: String,
    },
    GC {
        root: Vec<String>,
        dry_run: bool,
    },
    ImportImage {
        reference: String,
    },
    Oci {
        cmd: OciCommand,
    },
    Mount {
        name: String,
        mountpoint: String,
    },
    CreateImage {
        fs_opts: FsReadOptions,
        image_name: Option<String>,
    },
    ComputeId {
        fs_opts: FsReadOptions,
    },
    CreateDumpfile {
        fs_opts: FsReadOptions,
    },
    ImageObjects {
        name: String,
    },
    DumpFiles {
        image_name: String,
        files: Vec<PathBuf>,
        backing_path_only: bool,
    },
    Fsck {
        json: bool,
    },
}

Variants

Init

Initialize a new composefs repository with a metadata file.

Creates the repository directory (if it doesn’t exist) and writes a meta.json recording the digest algorithm. By default fs-verity is enabled on meta.json, signaling that all objects require verity. Use --insecure to skip (e.g. on tmpfs).

Fields

algorithm: Algorithm

The fs-verity algorithm identifier. Format: fsverity--<lg_blocksize>, e.g. fsverity-sha512-12

path: Option<PathBuf>

Path to the repository directory (created if it doesn’t exist). If omitted, uses –repo/–user/–system location.

insecure: bool

Do not enable fs-verity on meta.json (insecure repository).

reset_metadata: bool

Migrate an old-format repository: remove streams/ and images/ (which encode the algorithm) but keep objects/, then write fresh meta.json. Streams and images will need to be re-imported after migration.

Transaction

Take a transaction lock on the repository. This prevents garbage collection from occurring.

Cat

Reconstitutes a split stream and writes it to stdout

Fields

name: String

the name of the stream to cat, either a content identifier or prefixed with ‘ref/’

GC

Perform garbage collection

Fields

root: Vec<String>

Additional roots to keep (image or stream names)

dry_run: bool

Preview what would be deleted without actually deleting

ImportImage

Imports a composefs image (unsafe!)

Fields

reference: String

Oci

Commands for dealing with OCI images and layers

Fields

cmd: OciCommand

Mount

Mounts a composefs image, possibly enforcing fsverity of the image

Fields

name: String

the name of the image to mount, either an fs-verity hash or prefixed with ‘ref/’

mountpoint: String

the mountpoint

CreateImage

Read rootfs located at a path, add all files to the repo, then create the composefs image of the rootfs, commit it to the repo, and print its image object ID

Fields

fs_opts: FsReadOptions

image_name: Option<String>

optional reference name for the image, use as ‘ref/’ elsewhere

ComputeId

Read rootfs located at a path and compute the composefs image object id of the rootfs. Note that this does not create or commit the composefs image itself, and does not store any file objects in the repository.

Fields

fs_opts: FsReadOptions

CreateDumpfile

Read rootfs located at a path and dump full content of the rootfs to a composefs dumpfile, writing to stdout. Does not store any file objects in the repository.

Fields

fs_opts: FsReadOptions

ImageObjects

Lists all object IDs referenced by an image

Fields

name: String

the name of the image to read, either an object ID digest or prefixed with ‘ref/’

DumpFiles

Extract file information from a composefs image for specified files or directories

By default, outputs information in composefs dumpfile format

Fields

image_name: String

The name of the composefs image to read from, either an object ID digest or prefixed with ‘ref/’

files: Vec<PathBuf>

File or directory paths to process. If a path is a directory, its contents will be listed.

backing_path_only: bool

Show backing path information instead of dumpfile format For each file, prints either “inline” for files stored within the image, or a path relative to the object store for files stored extrenally

Fsck

Check repository integrity

Verifies fsverity digests of all objects, validates stream and image symlinks, and checks splitstream internal consistency. Exits with a non-zero status if corruption is found.

Fields

json: bool

Output results as JSON (always exits 0 unless the check itself fails)

Trait Implementations

impl Debug for Command

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

Formats the value using the given formatter.

impl FromArgMatches for Command

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Command

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand