Struct PushCommand 

pub struct PushCommand {
    pub executor: CommandExecutor,
    /* private fields */
}

Docker Push Command Builder

Implements the docker push command for uploading images to registries.

Docker Push Overview

The push command uploads images from the local Docker daemon to Docker registries (like Docker Hub, AWS ECR, or private registries). It supports:

• Single image push by name and tag
• All tags push for a repository
• Platform-specific manifest pushing
• Quiet mode for minimal output
• Content trust signing control

Image Naming

Images can be specified in several formats:

• image:tag - Image with specific tag
• registry/image:tag - Specific registry
• registry:port/image:tag - Custom registry port
• namespace/image:tag - Namespaced image (e.g., Docker Hub organizations)

Registry Authentication

Push operations typically require authentication. Use docker login first or configure registry credentials through Docker configuration files.

Examples

use docker_wrapper::PushCommand;
use docker_wrapper::DockerCommand;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Push to Docker Hub
    let output = PushCommand::new("username/myapp:v1.0")
        .execute()
        .await?;

    println!("Push success: {}", output.success);
    Ok(())
}

Fields

executor: CommandExecutor

Command executor for handling raw arguments and execution

Implementations

impl PushCommand

pub fn new<S: Into<String>>(image: S) -> Self

Create a new PushCommand instance

Arguments

• image - The image name to push (e.g., “myapp:latest”, “registry.com/myapp:v1.0”)

Examples

use docker_wrapper::PushCommand;

let push_cmd = PushCommand::new("myapp:latest");

pub fn all_tags(self) -> Self

Push all tags of an image to the repository

When enabled, pushes all available tags for the specified image repository. The image name should not include a specific tag when using this option.

Examples

use docker_wrapper::PushCommand;

let push_cmd = PushCommand::new("myregistry.com/myapp")
    .all_tags();

pub fn disable_content_trust(self) -> Self

Skip image signing (disable content trust)

By default, Docker may sign images when content trust is enabled. This option disables that signing process.

Examples

use docker_wrapper::PushCommand;

let push_cmd = PushCommand::new("myapp:latest")
    .disable_content_trust();

pub fn platform<S: Into<String>>(self, platform: S) -> Self

Push a platform-specific manifest as a single-platform image

Pushes only the specified platform variant of a multi-platform image. The image index won’t be pushed, meaning other manifests including attestations won’t be preserved.

Platform format: os[/arch[/variant]]

Common platform values:

• linux/amd64 - 64-bit Intel/AMD Linux
• linux/arm64 - 64-bit ARM Linux
• linux/arm/v7 - 32-bit ARM Linux
• windows/amd64 - 64-bit Windows

Examples

use docker_wrapper::PushCommand;

let push_cmd = PushCommand::new("myapp:latest")
    .platform("linux/amd64");

pub fn quiet(self) -> Self

Suppress verbose output

Reduces the amount of output during the push operation.

Examples

use docker_wrapper::PushCommand;

let push_cmd = PushCommand::new("myapp:latest")
    .quiet();

pub fn get_image(&self) -> &str

Get the image name

Examples

use docker_wrapper::PushCommand;

let push_cmd = PushCommand::new("myapp:latest");
assert_eq!(push_cmd.get_image(), "myapp:latest");

pub fn is_all_tags(&self) -> bool

Check if all tags mode is enabled

Examples

use docker_wrapper::PushCommand;

let push_cmd = PushCommand::new("myapp").all_tags();
assert!(push_cmd.is_all_tags());

pub fn is_quiet(&self) -> bool

Check if quiet mode is enabled

Examples

use docker_wrapper::PushCommand;

let push_cmd = PushCommand::new("myapp").quiet();
assert!(push_cmd.is_quiet());

pub fn get_platform(&self) -> Option<&str>

Get the platform if set

Examples

use docker_wrapper::PushCommand;

let push_cmd = PushCommand::new("myapp").platform("linux/arm64");
assert_eq!(push_cmd.get_platform(), Some("linux/arm64"));

pub fn is_content_trust_disabled(&self) -> bool

Check if content trust is disabled

Examples

use docker_wrapper::PushCommand;

let push_cmd = PushCommand::new("myapp").disable_content_trust();
assert!(push_cmd.is_content_trust_disabled());

pub fn get_executor(&self) -> &CommandExecutor

Get a reference to the command executor

pub fn get_executor_mut(&mut self) -> &mut CommandExecutor

Get a mutable reference to the command executor

Trait Implementations

impl Clone for PushCommand

fn clone(&self) -> PushCommand

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PushCommand

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

Formats the value using the given formatter.

impl Default for PushCommand

fn default() -> Self

Returns the “default value” for a type.

impl DockerCommand for PushCommand

type Output = CommandOutput

The output type this command produces

fn get_executor(&self) -> &CommandExecutor

Get the command executor for extensibility

fn get_executor_mut(&mut self) -> &mut CommandExecutor

Get mutable command executor for extensibility

fn build_command_args(&self) -> Vec<String>

Build the complete command arguments including subcommands

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

where Self: 'async_trait, 'life0: 'async_trait,

Execute the command and return the typed output

fn execute_command<'life0, 'async_trait>( &'life0 self, command_args: Vec<String>, ) -> Pin<Box<dyn Future<Output = Result<CommandOutput>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Helper method to execute the command with proper error handling

fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Self

Add a raw argument to the command (escape hatch)

fn args<I, S>(&mut self, args: I) -> &mut Self

where I: IntoIterator<Item = S>, S: AsRef<OsStr>,

Add multiple raw arguments to the command (escape hatch)

fn flag(&mut self, flag: &str) -> &mut Self

Add a flag option (e.g., –detach, –rm)

fn option(&mut self, key: &str, value: &str) -> &mut Self

Add a key-value option (e.g., –name value, –env key=value)