Struct PullCommand 

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

Docker Pull Command Builder

Implements the docker pull command for downloading images from registries.

Docker Pull Overview

The pull command downloads images from Docker registries (like Docker Hub) to the local Docker daemon. It supports:

• Single image pull by name and tag
• All tags pull for a repository
• Multi-platform image selection
• Quiet mode for minimal output
• Content trust verification control

Image Naming

Images can be specified in several formats:

• image - Defaults to latest tag
• image:tag - Specific tag
• image@digest - Specific digest
• registry/image:tag - Specific registry
• registry:port/image:tag - Custom registry port

Examples

use docker_wrapper::PullCommand;
use docker_wrapper::DockerCommand;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Pull latest nginx
    let output = PullCommand::new("nginx")
        .execute()
        .await?;

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

Fields

executor: CommandExecutor

Command executor for handling raw arguments and execution

Implementations

impl PullCommand

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

Create a new PullCommand instance

Arguments

• image - The image name to pull (e.g., “nginx:latest”, “alpine”, “redis:7.0”)

Examples

use docker_wrapper::PullCommand;

let pull_cmd = PullCommand::new("nginx:latest");

pub fn all_tags(self) -> Self

Download all tagged images in the repository

When enabled, pulls all available tags for the specified image repository. Cannot be used with specific tags or digests.

Examples

use docker_wrapper::PullCommand;

let pull_cmd = PullCommand::new("alpine")
    .all_tags();

pub fn disable_content_trust(self) -> Self

Skip image verification (disable content trust)

By default, Docker may verify image signatures when content trust is enabled. This option disables that verification.

Examples

use docker_wrapper::PullCommand;

let pull_cmd = PullCommand::new("nginx:latest")
    .disable_content_trust();

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

Set platform if server is multi-platform capable

Specifies the platform for which to pull the image when the image supports multiple platforms (architectures).

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::PullCommand;

let pull_cmd = PullCommand::new("nginx:latest")
    .platform("linux/arm64");

pub fn quiet(self) -> Self

Suppress verbose output

Reduces the amount of output during the pull operation.

Examples

use docker_wrapper::PullCommand;

let pull_cmd = PullCommand::new("nginx:latest")
    .quiet();

pub fn get_image(&self) -> &str

Get the image name

Examples

use docker_wrapper::PullCommand;

let pull_cmd = PullCommand::new("nginx:latest");
assert_eq!(pull_cmd.get_image(), "nginx:latest");

pub fn is_all_tags(&self) -> bool

Check if all tags mode is enabled

Examples

use docker_wrapper::PullCommand;

let pull_cmd = PullCommand::new("alpine").all_tags();
assert!(pull_cmd.is_all_tags());

pub fn is_quiet(&self) -> bool

Check if quiet mode is enabled

Examples

use docker_wrapper::PullCommand;

let pull_cmd = PullCommand::new("nginx").quiet();
assert!(pull_cmd.is_quiet());

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

Get the platform if set

Examples

use docker_wrapper::PullCommand;

let pull_cmd = PullCommand::new("nginx").platform("linux/arm64");
assert_eq!(pull_cmd.get_platform(), Some("linux/arm64"));

pub fn is_content_trust_disabled(&self) -> bool

Check if content trust is disabled

Examples

use docker_wrapper::PullCommand;

let pull_cmd = PullCommand::new("nginx").disable_content_trust();
assert!(pull_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 PullCommand

fn clone(&self) -> PullCommand

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PullCommand

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

Formats the value using the given formatter.

impl Default for PullCommand

fn default() -> Self

Returns the “default value” for a type.

impl DockerCommand for PullCommand

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)