Struct GenericCommand 

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

Generic Docker command for executing any Docker CLI command.

This provides an escape hatch for running arbitrary Docker commands that may not have dedicated command types in this library, such as:

• Plugin commands (e.g., docker scan, docker scout)
• Experimental features
• Future commands not yet implemented
• Custom or third-party extensions

Example

use docker_wrapper::{DockerCommand, GenericCommand};

// Execute a plugin command
let result = GenericCommand::new("scout")
    .arg("cves")
    .arg("alpine:latest")
    .execute()
    .await?;

if result.success {
    println!("Scan complete:\n{}", result.stdout);
}

// Execute with multiple arguments
let result = GenericCommand::new("trust")
    .args(["inspect", "--pretty", "alpine:latest"])
    .execute()
    .await?;

Fields

executor: CommandExecutor

Command executor

Implementations

impl GenericCommand

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

Create a new generic command.

Arguments

• command - The Docker subcommand to execute (e.g., “scan”, “scout”, “trust”)

Example

use docker_wrapper::GenericCommand;

let cmd = GenericCommand::new("scan");

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

Add a single argument to the command.

Example

use docker_wrapper::GenericCommand;

let cmd = GenericCommand::new("scan")
    .arg("--severity")
    .arg("high")
    .arg("alpine:latest");

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

where I: IntoIterator<Item = S>, S: Into<String>,

Add multiple arguments to the command.

Example

use docker_wrapper::GenericCommand;

let cmd = GenericCommand::new("scout")
    .args(["cves", "--format", "json", "alpine:latest"]);

Trait Implementations

impl Clone for GenericCommand

fn clone(&self) -> GenericCommand

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GenericCommand

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

Formats the value using the given formatter.

impl DockerCommand for GenericCommand

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)

fn with_timeout(&mut self, timeout: Duration) -> &mut Self

Set a timeout for command execution

fn with_timeout_secs(&mut self, seconds: u64) -> &mut Self

Set a timeout in seconds for command execution