Enum RegistryCommand 

pub enum RegistryCommand {
    Init {
        dir: PathBuf,
        id: String,
        key_out: Option<PathBuf>,
    },
    Add {
        dir: PathBuf,
        package: PathBuf,
        key: PathBuf,
    },
    Serve {
        dir: PathBuf,
        key: PathBuf,
        tokens: PathBuf,
        listen: String,
    },
    Rotate {
        dir: PathBuf,
        key: PathBuf,
        key_out: PathBuf,
    },
    Delegate {
        dir: PathBuf,
        key: PathBuf,
        delegate_out: PathBuf,
    },
    Revoke {
        dir: PathBuf,
        target: String,
        key: PathBuf,
        force: bool,
    },
    Resign {
        dir: PathBuf,
        key: PathBuf,
    },
    Conformance {
        index: String,
        org: Option<String>,
        name: String,
        key: Option<String>,
        read_only: bool,
        package: Option<String>,
        narrow_token_env: Option<String>,
        max_upload: u64,
        format: DeployFormatArg,
    },
    Token {
        tokens: PathBuf,
        organisations: Vec<String>,
        can: Vec<String>,
    },
    Yank {
        dir: PathBuf,
        package: String,
        version: String,
        undo: bool,
    },
    Withdraw {
        dir: PathBuf,
        package: String,
        version: String,
        reason: String,
    },
}

#2274: bynk registry subcommands.

Variants

Init

Create a registry: its config.json, and a signing key written outside the directory. Prints the key = "…" line consumers pin.

Fields

dir: PathBuf

The registry directory to create.

id: String

The registry’s id, which every signed line binds.

key_out: Option<PathBuf>

Where to write the signing key (default ./<id>.key).

Add

Pack a package, sign its index line, and add it to the registry.

Fields

dir: PathBuf

The registry directory.

package: PathBuf

The package’s directory (holding its bynk.toml).

key: PathBuf

The registry’s signing key.

Serve

Serve a registry directory with the publish API (#2287): plain HTTP, loopback by default — put a TLS-terminating proxy in front to serve beyond this machine.

Fields

dir: PathBuf

The registry directory.

key: PathBuf

The registry’s signing key (never inside the directory).

tokens: PathBuf

The tokens file bynk registry token writes (never inside the directory).

listen: String

The address to listen on.

Rotate

Append a link to the registry’s key chain (#2316): a new key, signed by the current chain key. Clients that trust an older key follow it.

Fields

dir: PathBuf

The registry directory (or a copy holding its config.json).

key: PathBuf

The current (newest) chain key.

key_out: PathBuf

Where to write the new key (never inside the directory).

Delegate

Delegate signing to a new key (#2316): it may sign index lines, and nothing else. Use it as serve’s or add’s --key, keeping the chain key offline.

Fields

dir: PathBuf

The registry directory (or a copy holding its config.json).

key: PathBuf

A chain key, which signs the delegation.

delegate_out: PathBuf

Where to write the delegated key (never inside the directory).

Revoke

Revoke a delegated key (#2316): lines it signed are refused from then on, so re-sign them with another key first (resign).

Fields

dir: PathBuf

The registry directory (or a copy holding its config.json).

target: String

The delegate to revoke, ed25519:….

key: PathBuf

A chain key, which signs the revocation.

force: bool

Revoke even if some lines would be left with no valid signer.

Resign

Re-sign every index line with a key (#2316): the newest chain key or a valid delegate. Only each line’s sig changes.

Fields

dir: PathBuf

The registry directory.

key: PathBuf

The signing key.

Conformance

Check a registry against the protocol (#2311): every observable rule a server must keep, run against its URL. A full run publishes one throwaway package under --org and leaves it yanked; --read-only publishes nothing.

Fields

index: String

The registry’s index URL.

org: Option<String>

The organisation the token may publish and yank under.

name: String

The registry name the token is found under (BYNK_REGISTRY_<NAME>_TOKEN, or the credentials file).

key: Option<String>

The registry’s key to pin (ed25519:…); trusted on first use for the run otherwise.

read_only: bool

Publish nothing: check config.json, and --package if given.

package: Option<String>

The existing org/package a --read-only run reads back.

narrow_token_env: Option<String>

An environment variable holding a token that can’t act for --org, for the auth.scope check (skipped without one).

max_upload: u64

The upload cap, in bytes, to test 413 against.

format: DeployFormatArg

Output format.

Token

Mint a publish token for bynk registry serve (#2287): printed once; only its hash is stored in the tokens file.

Fields

tokens: PathBuf

The tokens file to add it to.

organisations: Vec<String>

An organisation it may act for (repeatable).

can: Vec<String>

What it may do: publish, yank (repeatable or comma-separated; both by default).

Yank

Mark a version yanked — kept for locked builds, never newly chosen.

Fields

dir: PathBuf

The registry directory.

package: String

org/package.

version: String

The version to yank.

undo: bool

Clear the yank instead.

Withdraw

Withdraw a version (#2330): a takedown. Yanks its line, records the reason clients print, and deletes its archive. Final — there is no undo.

Fields

dir: PathBuf

The registry directory.

package: String

org/package.

version: String

The version to withdraw.

reason: String

Why, as clients will print it (one line, at most 500 characters).

Trait Implementations

impl Debug for RegistryCommand

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

Formats the value using the given formatter.

impl FromArgMatches for RegistryCommand

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 RegistryCommand

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