Enum BreakGlassCommand 

pub enum BreakGlassCommand {
    Propose {
        action: Action,
        target: String,
        reason: String,
        ttl: Option<Time>,
    },
    Approve {
        proposal: Uuid,
        sign_with: Option<PathBuf>,
        key_id: Option<String>,
    },
    Withdraw {
        proposal: Uuid,
    },
    List {
        pending: bool,
        proposal: Option<Uuid>,
    },
}

The break-glass subcommands.

Variants

Propose

Open a proposal, which a second person then approves.

Fields

action: Action

The transition the proposal authorizes.

target: String

What the transition applies to: a topic, a broker id, or a partition, depending on the action.

reason: String

Free text that says why the transition is needed.

ttl: Option<Time>

How long the proposal stays open. Takes any time unit, so 30m, 1h and 90s all work, and a number with no unit is refused. The broker caps it at break_glass.proposal_ttl. Omit to take that value.

Approve

Add one approval to a proposal.

The broker refuses the proposer, a principal outside break_glass.approvers, and a principal that already approved. Those three checks are what make this a two-person rule rather than a two-click rule.

Fields

proposal: Uuid

The proposal to approve.

sign_with: Option<PathBuf>

The PKCS#8 Ed25519 key that signs the approval. The broker demands one for every action in break_glass.signed_actions.

key_id: Option<String>

The operator key that --sign-with holds, as [[operator_keys]] names it.

Withdraw

Withdraw a proposal, so nothing can spend it.

A withdraw rides the approve api key with the request’s withdraw flag set. Approve and withdraw both name a proposal that exists and both act on it, so they share one request. A propose names no proposal, because a propose is what creates one.

Fields

proposal: Uuid

The proposal to withdraw.

List

Print the proposals and their approvals.

Fields

pending: bool

Drop the proposals that a transition consumed, that an operator withdrew, and that expired.

proposal: Option<Uuid>

Print this proposal alone.

Trait Implementations

impl FromArgMatches for BreakGlassCommand

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 BreakGlassCommand

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