Enum Command 

pub(crate) enum Command {
    Init {
        algorithm: Algorithm,
        path: Option<PathBuf>,
        insecure: bool,
        reset_metadata: bool,
        erofs_version: Option<ErofsVersion>,
    },
    Transaction,
    Cat {
        name: String,
    },
    GC {
        root: Vec<String>,
        dry_run: bool,
    },
    ImportImage {
        reference: String,
    },
    Oci {
        cmd: OciCommand,
    },
    Ostree {
        cmd: OstreeCommand,
    },
    Mount {
        name: String,
        mountpoint: String,
        upperdir: Option<PathBuf>,
        workdir: Option<PathBuf>,
        read_write: bool,
    },
    CreateImage {
        fs_opts: FsReadOptions,
        image_name: Option<String>,
    },
    ComputeId {
        fs_opts: FsReadOptions,
    },
    ComputeKarg {
        path: PathBuf,
        no_propagate_usr_to_root: bool,
    },
    CreateDumpfile {
        fs_opts: FsReadOptions,
    },
    ImageObjects {
        name: String,
    },
    DumpFiles {
        image_name: String,
        files: Vec<PathBuf>,
        backing_path_only: bool,
    },
    Fsck {
        json: bool,
        metadata_only: bool,
    },
    Varlink {
        address: Option<PathBuf>,
    },
    Mkcomposefs {
        args: Vec<OsString>,
    },
    ComposefsInfo {
        args: Vec<OsString>,
    },
}

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.

erofs_version: Option<ErofsVersion>

Default EROFS format version for images in this repository. V1 is compatible with C mkcomposefs 1.0.8; V2 is the native format. If omitted, falls back to the global --erofs-version flag, then defaults to V2.

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

Ostree

Fields

cmd: OstreeCommand

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

upperdir: Option<PathBuf>

Writable upper layer directory for overlayfs

workdir: Option<PathBuf>

Work directory for overlayfs (required with –upperdir)

read_write: bool

Mount read-write (requires –upperdir)

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

ComputeKarg

Read rootfs located at a path and compute the composefs kernel argument string.

Like compute-id but outputs the full kernel argument rather than the bare digest, choosing the argument name based on the EROFS format version:

V1: composefs.digest=v1-sha256-12: V2: composefs=

Use –erofs-version to select the format. The boot transformation (SELinux relabeling, empty /boot and /sysroot) is always applied — this command produces a karg for a sealed boot image.

Example (in a Containerfile): cfsctl –erofs-version 1 compute-karg /mnt/base > /etc/kernel/cmdline

Fields

path: PathBuf

The path to the filesystem

no_propagate_usr_to_root: bool

Don’t copy /usr metadata to root directory (use if root already has well-defined metadata)

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)

metadata_only: bool

Skip per-object fs-verity verification; check only metadata and symlink structure (much faster on large repositories)

Varlink

Serve the varlink RPC API on a Unix socket or systemd socket.

A single service answers both the org.composefs.Repository and (when the oci feature is enabled) org.composefs.Oci interfaces on one socket.

Fields

address: Option<PathBuf>

Unix socket path to listen on (omit when using systemd socket activation).

Mkcomposefs

Run mkcomposefs (C-compatible image builder); hidden, also available via argv0 dispatch.

Fields

args: Vec<OsString>

Arguments forwarded verbatim to mkcomposefs

ComposefsInfo

Run composefs-info (C-compatible image inspector); hidden, also available via argv0 dispatch.

Fields

args: Vec<OsString>

Arguments forwarded verbatim to composefs-info

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