Enum FreezeCommand 

pub enum FreezeCommand {
    Set {
        scope: ScopeArgs,
        reason: String,
        signing: FreezeSigningArgs,
    },
    List {
        scope: Option<String>,
        verify_signatures: bool,
        operator_keys: Option<PathBuf>,
    },
    Clear {
        scope: ScopeArgs,
        proposal: Uuid,
        reason: String,
        signing: FreezeSigningArgs,
    },
}

The freeze registry subcommands.

Variants

Set

Freeze a topic or a topic-name prefix.

A freeze is the safe direction, so one command sets it. The broker takes an unsigned freeze unless freeze.require_signature is on, and an unsigned entry is an attestation rather than a proof.

Fields

scope: ScopeArgs

The scope to freeze.

reason: String

Free text that says why. The broker keeps it in the metadata log and in the audit event.

signing: FreezeSigningArgs

The detached operator signature, if the operator makes one.

List

Print the live registry entries.

Fields

scope: Option<String>

Only print the entries whose scope is exactly this.

verify_signatures: bool

Check every returned entry against operator public keys on this machine, rather than taking the broker’s word for the registry.

operator_keys: Option<PathBuf>

A TOML file carrying the [[operator_keys]] block, which may be the broker.toml the cluster runs on.

Clear

Lift a freeze.

A thaw is the dangerous direction. The broker refuses one that names no approved break-glass proposal, and it refuses one that carries no signature whatever its configuration says.

Fields

scope: ScopeArgs

The scope to thaw. It must name the entry exactly: a freeze on --prefix tenant-a. is not lifted by naming one topic under it.

proposal: Uuid

The approved break-glass proposal that authorizes the thaw.

reason: String

Free text that says why the freeze is lifted. The metadata log and the audit event keep it, so the record names the reason as well as the person.

signing: FreezeSigningArgs

The detached operator signature. A thaw always needs one.

Trait Implementations

impl FromArgMatches for FreezeCommand

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 FreezeCommand

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