Struct PackagePublish

pub struct PackagePublish {
    pub env: WasmerEnv,
    pub dry_run: bool,
    pub quiet: bool,
    pub package_namespace: Option<String>,
    pub package_name: Option<String>,
    pub package_version: Option<Version>,
    pub no_validate: bool,
    pub package_path: PathBuf,
    pub wait: PublishWait,
    pub timeout: Duration,
    pub bump: bool,
    pub non_interactive: bool,
}

Publish (push and tag) a package to the registry.

Fields

env: WasmerEnv

dry_run: bool

Run the publish logic without sending anything to the registry server

quiet: bool

Run the publish command without any output

package_namespace: Option<String>

Override the namespace of the package to upload

package_name: Option<String>

Override the name of the package to upload

package_version: Option<Version>

Override the package version of the uploaded package in the wasmer.toml

no_validate: bool

Skip validation of the uploaded package

package_path: PathBuf

Directory containing the wasmer.toml, or a custom *.toml manifest file.

Defaults to current working directory.

wait: PublishWait

Wait for package to be available on the registry before exiting.

timeout: Duration

Timeout (in seconds) for the publish query to the registry.

Note that this is not the timeout for the entire publish process, but for each individual query to the registry during the publish flow.

bump: bool

Whether or not the patch field of the version of the package - if any - should be bumped.

non_interactive: bool

Do not prompt for user input.

Implementations

impl PackagePublish

pub async fn publish( &self, client: &WasmerClient, manifest_path: &Path, manifest: &Manifest, allow_unnamed: bool, ) -> Result<PackageIdent>

Trait Implementations

impl Args for PackagePublish

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::ArgGroup::id] for this set of arguments

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

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

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

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

impl AsyncCliCommand for PackagePublish

type Output = PackageIdent

fn run_async<'async_trait>( self, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Error>> + Send + 'async_trait>>

where Self: 'async_trait,

fn setup(&self, done: Receiver<()>) -> Option<JoinHandle<Result<()>>>

impl CommandFactory for PackagePublish

fn command<'b>() -> Command

Build a [Command] that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a [Command] that can update self.

impl Debug for PackagePublish

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

Formats the value using the given formatter.

impl FromArgMatches for PackagePublish

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( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for PackagePublish

fn parse() -> Self

Parse from std::env::args_os(), [exit][Error::exit] on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, [exit][Error::exit] on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, [exit][Error::exit] on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.