docker_pose/
docker.rs

1use crate::verbose::Verbosity;
2use crate::{cmd_call, cmd_call_to_string, cmd_exit_code, cmd_write_stderr, cmd_write_stdout};
3
4use std::env::var;
5use std::io;
6use std::process::Output;
7
8pub struct DockerCommand {
9    pub docker_bin: String,
10    pub verbosity: Verbosity,
11}
12
13impl DockerCommand {
14    pub fn new(verbosity: Verbosity) -> Self {
15        Self {
16            docker_bin: var("DOCKER_BIN").unwrap_or("docker".to_string()),
17            verbosity,
18        }
19    }
20
21    pub fn call_to_string(&self, args: &[&str]) -> String {
22        cmd_call_to_string(&self.docker_bin, args)
23    }
24
25    pub fn call_cmd(
26        &self,
27        args: &[&str],
28        output_stdout: bool,
29        output_stderr: bool,
30    ) -> io::Result<Output> {
31        cmd_call(
32            &self.docker_bin,
33            args,
34            output_stdout,
35            output_stderr,
36            &self.verbosity,
37        )
38    }
39
40    pub fn call_compose_cmd(
41        &self,
42        cmd: &str,
43        filenames: &[&str],
44        args: &[&str],
45        cmd_args: &[&str],
46        output_stdout: bool,
47        output_stderr: bool,
48    ) -> io::Result<Output> {
49        let mut docker_args = vec!["compose"];
50        for filename in filenames {
51            docker_args.push("-f");
52            docker_args.push(filename);
53        }
54        for arg in args {
55            docker_args.push(arg);
56        }
57        docker_args.push(cmd);
58        for arg in cmd_args {
59            docker_args.push(arg);
60        }
61        self.call_cmd(&docker_args, output_stdout, output_stderr)
62    }
63
64    pub fn call_compose_config(
65        &self,
66        filenames: &[&str],
67        no_consistency: bool,
68        no_interpolate: bool,
69        output_stdout: bool,
70        output_stderr: bool,
71    ) -> io::Result<Output> {
72        let mut cmd_args = Vec::new();
73        cmd_args.push("--no-normalize");
74        if no_consistency {
75            cmd_args.push("--no-consistency");
76        }
77        if no_interpolate {
78            cmd_args.push("--no-interpolate");
79        }
80        self.call_compose_cmd(
81            "config",
82            filenames,
83            &Vec::default(),
84            &cmd_args,
85            output_stdout,
86            output_stderr,
87        )
88    }
89
90    pub fn get_manifest_inspect(&self, image: &str) -> io::Result<Output> {
91        self.call_cmd(&["manifest", "inspect", "--insecure", image], false, false)
92    }
93
94    pub fn get_image_inspect(&self, image: &str) -> io::Result<Output> {
95        self.call_cmd(&["image", "inspect", image], false, false)
96    }
97
98    pub fn pull_image(
99        &self,
100        image: &str,
101        output_stdout: bool,
102        output_stderr: bool,
103    ) -> io::Result<Output> {
104        self.call_cmd(&["pull", image], output_stdout, output_stderr)
105    }
106
107    pub fn write_stderr(&self, stderr: &[u8]) {
108        cmd_write_stderr(&self.docker_bin, stderr);
109    }
110
111    pub fn write_stdout(&self, stdout: &[u8]) {
112        cmd_write_stdout(&self.docker_bin, stdout);
113    }
114
115    pub fn exit_code(&self, output: &Output) -> i32 {
116        cmd_exit_code(&self.docker_bin, output)
117    }
118}