docker-wrapper 0.11.1

A Docker CLI wrapper for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Docker network disconnect command implementation.

use crate::command::{CommandExecutor, CommandOutput, DockerCommand};
use crate::error::Result;
use async_trait::async_trait;

/// Docker network disconnect command builder
#[derive(Debug, Clone)]
pub struct NetworkDisconnectCommand {
    /// Network name
    network: String,
    /// Container name or ID
    container: String,
    /// Force disconnection
    force: bool,
    /// Command executor
    pub executor: CommandExecutor,
}

impl NetworkDisconnectCommand {
    /// Create a new network disconnect command
    #[must_use]
    pub fn new(network: impl Into<String>, container: impl Into<String>) -> Self {
        Self {
            network: network.into(),
            container: container.into(),
            force: false,
            executor: CommandExecutor::new(),
        }
    }

    /// Force disconnection
    #[must_use]
    pub fn force(mut self) -> Self {
        self.force = true;
        self
    }

    /// Execute the command
    ///
    /// # Errors
    ///
    /// Returns an error if the Docker daemon is not running or the command fails
    pub async fn run(&self) -> Result<NetworkDisconnectResult> {
        self.execute().await.map(NetworkDisconnectResult::from)
    }
}

#[async_trait]
impl DockerCommand for NetworkDisconnectCommand {
    type Output = CommandOutput;

    fn build_command_args(&self) -> Vec<String> {
        let mut args = vec!["network".to_string(), "disconnect".to_string()];

        if self.force {
            args.push("--force".to_string());
        }

        args.push(self.network.clone());
        args.push(self.container.clone());
        args.extend(self.executor.raw_args.clone());
        args
    }

    fn get_executor(&self) -> &CommandExecutor {
        &self.executor
    }

    fn get_executor_mut(&mut self) -> &mut CommandExecutor {
        &mut self.executor
    }

    async fn execute(&self) -> Result<Self::Output> {
        let args = self.build_command_args();
        let command_name = args[0].clone();
        let command_args = args[1..].to_vec();
        self.executor
            .execute_command(&command_name, command_args)
            .await
    }
}

/// Result from network disconnect command
#[derive(Debug, Clone)]
pub struct NetworkDisconnectResult {
    /// Raw command output
    pub raw_output: CommandOutput,
}

impl From<CommandOutput> for NetworkDisconnectResult {
    fn from(output: CommandOutput) -> Self {
        Self { raw_output: output }
    }
}

impl NetworkDisconnectResult {
    /// Check if the command was successful
    #[must_use]
    pub fn is_success(&self) -> bool {
        self.raw_output.success
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_network_disconnect_basic() {
        let cmd = NetworkDisconnectCommand::new("my-network", "my-container");
        let args = cmd.build_command_args();
        assert_eq!(
            args,
            vec!["network", "disconnect", "my-network", "my-container"]
        );
    }

    #[test]
    fn test_network_disconnect_force() {
        let cmd = NetworkDisconnectCommand::new("my-network", "my-container").force();
        let args = cmd.build_command_args();
        assert_eq!(
            args,
            vec![
                "network",
                "disconnect",
                "--force",
                "my-network",
                "my-container"
            ]
        );
    }
}