docker-pose 0.5.0

Command line tool to play with 🐳 Docker Compose files.
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

use crate::verbose::Verbosity;
use crate::{cmd_call, cmd_call_to_string, cmd_exit_code, cmd_write_stderr, cmd_write_stdout};

use std::env::var;
use std::io;
use std::process::Output;

pub struct DockerCommand {
    pub docker_bin: String,
    pub verbosity: Verbosity,
}

impl DockerCommand {
    pub fn new(verbosity: Verbosity) -> Self {
        Self {
            docker_bin: var("DOCKER_BIN").unwrap_or("docker".to_string()),
            verbosity,
        }
    }

    pub fn call_to_string(&self, args: &[&str]) -> String {
        cmd_call_to_string(&self.docker_bin, args)
    }

    pub fn call_cmd(
        &self,
        args: &[&str],
        output_stdout: bool,
        output_stderr: bool,
    ) -> io::Result<Output> {
        cmd_call(
            &self.docker_bin,
            args,
            output_stdout,
            output_stderr,
            &self.verbosity,
        )
    }

    pub fn call_compose_cmd(
        &self,
        cmd: &str,
        filenames: &[&str],
        args: &[&str],
        cmd_args: &[&str],
        output_stdout: bool,
        output_stderr: bool,
    ) -> io::Result<Output> {
        let mut docker_args = vec!["compose"];
        for filename in filenames {
            docker_args.push("-f");
            docker_args.push(filename);
        }
        for arg in args {
            docker_args.push(arg);
        }
        docker_args.push(cmd);
        for arg in cmd_args {
            docker_args.push(arg);
        }
        self.call_cmd(&docker_args, output_stdout, output_stderr)
    }

    pub fn call_compose_config(
        &self,
        filenames: &[&str],
        no_consistency: bool,
        no_interpolate: bool,
        output_stdout: bool,
        output_stderr: bool,
    ) -> io::Result<Output> {
        let mut cmd_args = Vec::new();
        cmd_args.push("--no-normalize");
        if no_consistency {
            cmd_args.push("--no-consistency");
        }
        if no_interpolate {
            cmd_args.push("--no-interpolate");
        }
        self.call_compose_cmd(
            "config",
            filenames,
            &Vec::default(),
            &cmd_args,
            output_stdout,
            output_stderr,
        )
    }

    pub fn get_manifest_inspect(&self, image: &str) -> io::Result<Output> {
        self.call_cmd(&["manifest", "inspect", "--insecure", image], false, false)
    }

    pub fn get_image_inspect(&self, image: &str) -> io::Result<Output> {
        self.call_cmd(&["image", "inspect", image], false, false)
    }

    pub fn pull_image(
        &self,
        image: &str,
        output_stdout: bool,
        output_stderr: bool,
    ) -> io::Result<Output> {
        self.call_cmd(&["pull", image], output_stdout, output_stderr)
    }

    pub fn write_stderr(&self, stderr: &[u8]) {
        cmd_write_stderr(&self.docker_bin, stderr);
    }

    pub fn write_stdout(&self, stdout: &[u8]) {
        cmd_write_stdout(&self.docker_bin, stdout);
    }

    pub fn exit_code(&self, output: &Output) -> i32 {
        cmd_exit_code(&self.docker_bin, output)
    }
}