Struct RunCommand 

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

Docker run command builder with fluent API

Fields

executor: CommandExecutor

Command executor for extensibility

Implementations

impl RunCommand

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

Create a new run command for the specified image

pub fn name(self, name: impl Into<String>) -> Self

Set the container name

pub fn detach(self) -> Self

Run in detached mode (background)

pub fn env(self, key: impl Into<String>, value: impl Into<String>) -> Self

Add an environment variable

pub fn envs(self, vars: HashMap<String, String>) -> Self

Add multiple environment variables

pub fn port(self, host_port: u16, container_port: u16) -> Self

Add a port mapping

pub fn dynamic_port(self, container_port: u16) -> Self

Add a dynamic port mapping (Docker assigns host port)

pub fn port_dyn(self, container_port: u16) -> Self

Alias for dynamic_port() - Add a dynamic port mapping (Docker assigns host port)

pub fn volume( self, source: impl Into<String>, target: impl Into<String>, ) -> Self

Add a volume mount

pub fn bind(self, source: impl Into<String>, target: impl Into<String>) -> Self

Add a bind mount

pub fn volume_ro( self, source: impl Into<String>, target: impl Into<String>, ) -> Self

Add a read-only volume mount

pub fn workdir(self, workdir: impl Into<PathBuf>) -> Self

Set working directory

pub fn entrypoint(self, entrypoint: impl Into<String>) -> Self

Override entrypoint

pub fn cmd(self, command: Vec<String>) -> Self

Set command to run in container

pub fn interactive(self) -> Self

Enable interactive mode

pub fn tty(self) -> Self

Allocate a TTY

pub fn remove(self) -> Self

Remove container automatically when it exits

pub fn rm(self) -> Self

Alias for remove() - Remove container automatically when it exits (–rm flag)

pub fn it(self) -> Self

Convenience method for interactive TTY mode

pub fn memory(self, memory: impl Into<String>) -> Self

Set memory limit (e.g., “1g”, “512m”)

pub fn cpus(self, cpus: impl Into<String>) -> Self

Set number of CPUs (e.g., “2.0”, “1.5”)

pub fn cpu_shares(self, shares: i64) -> Self

Set CPU shares (relative weight)

pub fn cpu_period(self, period: i64) -> Self

Set CPU CFS period in microseconds

pub fn cpu_quota(self, quota: i64) -> Self

Set CPU CFS quota in microseconds

pub fn cpuset_cpus(self, cpus: impl Into<String>) -> Self

Set CPUs in which to allow execution (e.g., “0-3”, “0,1”)

pub fn cpuset_mems(self, mems: impl Into<String>) -> Self

Set MEMs in which to allow execution (e.g., “0-3”, “0,1”)

pub fn memory_swap(self, swap: impl Into<String>) -> Self

Set memory + swap limit (e.g., “2g”, “-1” for unlimited)

pub fn memory_reservation(self, reservation: impl Into<String>) -> Self

Set memory soft limit (e.g., “500m”)

pub fn user(self, user: impl Into<String>) -> Self

Set username or UID (format: <name|uid>[:<group|gid>])

pub fn privileged(self) -> Self

Give extended privileges to this container

pub fn hostname(self, hostname: impl Into<String>) -> Self

Set container host name

pub fn restart(self, restart: impl Into<String>) -> Self

Set restart policy (e.g., “always”, “unless-stopped”, “on-failure”, “no”)

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

Set platform if server is multi-platform capable (e.g., “linux/amd64”)

pub fn runtime(self, runtime: impl Into<String>) -> Self

Set runtime to use for this container

pub fn isolation(self, isolation: impl Into<String>) -> Self

Set container isolation technology

pub fn pull(self, pull: impl Into<String>) -> Self

Set pull image policy (“always”, “missing”, “never”)

pub fn cidfile(self, cidfile: impl Into<String>) -> Self

Write the container ID to the specified file

pub fn domainname(self, domainname: impl Into<String>) -> Self

Set container NIS domain name

pub fn mac_address(self, mac: impl Into<String>) -> Self

Set container MAC address (e.g., “92:d0:c6:0a:29:33”)

pub fn log_driver(self, driver: impl Into<String>) -> Self

Set logging driver for the container

pub fn volume_driver(self, driver: impl Into<String>) -> Self

Set optional volume driver for the container

pub fn userns(self, userns: impl Into<String>) -> Self

Set user namespace to use

pub fn uts(self, uts: impl Into<String>) -> Self

Set UTS namespace to use

pub fn pid(self, pid: impl Into<String>) -> Self

Set PID namespace to use

pub fn ipc(self, ipc: impl Into<String>) -> Self

Set IPC mode to use

pub fn cgroupns(self, cgroupns: impl Into<String>) -> Self

Set cgroup namespace to use (host|private)

pub fn cgroup_parent(self, parent: impl Into<String>) -> Self

Set optional parent cgroup for the container

pub fn kernel_memory(self, memory: impl Into<String>) -> Self

Set kernel memory limit

pub fn memory_swappiness(self, swappiness: i32) -> Self

Tune container memory swappiness (0 to 100)

pub fn oom_score_adj(self, score: i32) -> Self

Tune host’s OOM preferences (-1000 to 1000)

pub fn pids_limit(self, limit: i64) -> Self

Tune container pids limit (set -1 for unlimited)

pub fn shm_size(self, size: impl Into<String>) -> Self

Set size of /dev/shm (e.g., “64m”)

pub fn stop_signal(self, signal: impl Into<String>) -> Self

Set signal to stop the container (e.g., “SIGTERM”, “SIGKILL”)

pub fn stop_timeout(self, timeout: i32) -> Self

Set timeout (in seconds) to stop a container

pub fn detach_keys(self, keys: impl Into<String>) -> Self

Override the key sequence for detaching a container

pub fn no_sig_proxy(self) -> Self

Disable proxying received signals to the process

pub fn read_only(self) -> Self

Mount the container’s root filesystem as read only

pub fn init(self) -> Self

Run an init inside the container that forwards signals and reaps processes

pub fn oom_kill_disable(self) -> Self

Disable OOM Killer

pub fn no_healthcheck(self) -> Self

Disable any container-specified HEALTHCHECK

pub fn enable_content_trust(self) -> Self

Enable image verification (disable content trust is false)

pub fn publish_all(self) -> Self

Publish all exposed ports to random ports

pub fn quiet(self) -> Self

Suppress the pull output

pub fn dns(self, dns: impl Into<String>) -> Self

Add custom DNS server

pub fn dns_servers(self, servers: Vec<String>) -> Self

Add multiple DNS servers

pub fn dns_option(self, option: impl Into<String>) -> Self

Add DNS option

pub fn dns_search(self, domain: impl Into<String>) -> Self

Add DNS search domain

pub fn add_host(self, mapping: impl Into<String>) -> Self

Add host-to-IP mapping (format: “hostname:ip”)

pub fn cap_add(self, capability: impl Into<String>) -> Self

Add Linux capability

pub fn cap_drop(self, capability: impl Into<String>) -> Self

Drop Linux capability

pub fn security_opt(self, option: impl Into<String>) -> Self

Add security option

pub fn device(self, device: impl Into<String>) -> Self

Add host device to container

pub fn tmpfs(self, path: impl Into<String>) -> Self

Mount tmpfs directory

pub fn expose(self, port: impl Into<String>) -> Self

Expose port without publishing it

pub fn env_file(self, file: impl Into<PathBuf>) -> Self

Read environment variables from file

pub fn label(self, label: impl Into<String>) -> Self

Add metadata label

pub fn label_file(self, file: impl Into<PathBuf>) -> Self

Read labels from file

pub fn network_alias(self, alias: impl Into<String>) -> Self

Add network alias for the container

pub fn group_add(self, group: impl Into<String>) -> Self

Add supplementary group for the user

pub fn attach(self, stream: impl Into<String>) -> Self

Attach to STDIN, STDOUT or STDERR

pub fn log_opt(self, option: impl Into<String>) -> Self

Add log driver option

pub fn storage_opt(self, option: impl Into<String>) -> Self

Add storage driver option

pub fn ulimit(self, limit: impl Into<String>) -> Self

Set ulimit option

pub fn volumes_from(self, container: impl Into<String>) -> Self

Mount volumes from another container

pub fn link(self, link: impl Into<String>) -> Self

Add link to another container (deprecated)

pub fn link_local_ip(self, ip: impl Into<String>) -> Self

Add container IPv4/IPv6 link-local address

pub fn health_cmd(self, cmd: impl Into<String>) -> Self

Set health check command

pub fn health_interval(self, interval: impl Into<String>) -> Self

Set health check interval

pub fn health_retries(self, retries: i32) -> Self

Set health check retries

pub fn health_timeout(self, timeout: impl Into<String>) -> Self

Set health check timeout

pub fn health_start_period(self, period: impl Into<String>) -> Self

Set health check start period

pub fn health_start_interval(self, interval: impl Into<String>) -> Self

Set health check start interval

pub fn mount(self, mount: impl Into<String>) -> Self

Add advanced mount configuration

pub fn network(self, network: impl Into<String>) -> Self

Connect to a network

pub fn gpus(self, gpus: impl Into<String>) -> Self

Set GPU devices to add to the container

pub fn annotation( self, key: impl Into<String>, value: impl Into<String>, ) -> Self

Add custom annotation (key=value format)

pub fn sysctl(self, key: impl Into<String>, value: impl Into<String>) -> Self

Set kernel parameter (key=value format)

pub fn blkio_weight(self, weight: u16) -> Self

Set block IO weight (10-1000)

pub fn blkio_weight_device(self, device_weight: impl Into<String>) -> Self

Set block IO weight for a specific device (format: DEVICE:WEIGHT)

pub fn device_read_bps(self, device_rate: impl Into<String>) -> Self

Limit read rate (bytes per second) from a device (format: DEVICE:RATE)

pub fn device_write_bps(self, device_rate: impl Into<String>) -> Self

Limit write rate (bytes per second) to a device (format: DEVICE:RATE)

pub fn device_read_iops(self, device_rate: impl Into<String>) -> Self

Limit read rate (IO per second) from a device (format: DEVICE:RATE)

pub fn device_write_iops(self, device_rate: impl Into<String>) -> Self

Limit write rate (IO per second) to a device (format: DEVICE:RATE)

pub fn cpu_rt_period(self, period: i64) -> Self

Limit CPU real-time period in microseconds

pub fn cpu_rt_runtime(self, runtime: i64) -> Self

Limit CPU real-time runtime in microseconds

pub fn ip(self, ip: impl Into<String>) -> Self

Set container IPv4 address (e.g., “172.30.100.104”)

pub fn ip6(self, ip6: impl Into<String>) -> Self

Set container IPv6 address (e.g., “2001:db8::33”)

pub fn device_cgroup_rule(self, rule: impl Into<String>) -> Self

Add device cgroup rule

impl RunCommand

pub async fn stream<F>(&self, handler: F) -> Result<StreamResult>

where F: FnMut(OutputLine) + Send + 'static,

Run the container with streaming output

Note: This will fail if the container is run in detached mode.

Examples

use docker_wrapper::RunCommand;
use docker_wrapper::StreamHandler;

let result = RunCommand::new("alpine")
    .cmd(vec!["echo".to_string(), "Hello, World!".to_string()])
    .stream(StreamHandler::print())
    .await?;

Errors

Returns an error if the container is detached or encounters an I/O error

Trait Implementations

impl Clone for RunCommand

fn clone(&self) -> RunCommand

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RunCommand

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

Formats the value using the given formatter.

impl DockerCommand for RunCommand

type Output = ContainerId

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)

impl StreamableCommand for RunCommand

fn stream<'life0, 'async_trait, F>( &'life0 self, handler: F, ) -> Pin<Box<dyn Future<Output = Result<StreamResult>> + Send + 'async_trait>>

where F: FnMut(OutputLine) + Send + 'static + 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Run the command with streaming output

fn stream_channel<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(Receiver<OutputLine>, StreamResult)>> + Send + 'async_trait>>

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

Run the command with streaming output via a channel