swiftide-docker-executor 0.13.5

A docker executor for swiftide agent tools
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::{collections::HashMap, path::PathBuf, time::Duration};
use uuid::Uuid;

use crate::{DockerExecutorError, RunningDockerExecutor};

/// Build a docker image with bollard and start it up
#[derive(Clone, Debug)]
pub struct DockerExecutor {
    pub(crate) context_path: PathBuf,
    pub(crate) image_name: String,
    pub(crate) dockerfile: Option<PathBuf>,
    pub(crate) container_uuid: Uuid,
    pub(crate) user: Option<String>,
    pub(crate) env_clear: bool,
    pub(crate) remove_env: Vec<String>,
    pub(crate) env: HashMap<String, String>,
    pub(crate) retain_on_drop: bool,
    pub(crate) default_timeout: Option<Duration>,
    pub(crate) workdir: PathBuf,
}

impl Default for DockerExecutor {
    fn default() -> Self {
        Self {
            container_uuid: Uuid::new_v4(),
            context_path: ".".into(),
            image_name: "docker-executor".into(),
            dockerfile: Some("Dockerfile".into()),
            user: None,
            env: HashMap::new(),
            env_clear: false,
            remove_env: vec![],
            retain_on_drop: false,
            default_timeout: None,
            workdir: "/app".into(),
        }
    }
}

impl DockerExecutor {
    /// Set the path to build the context from (default ".")
    pub fn with_context_path(&mut self, path: impl Into<PathBuf>) -> &mut Self {
        self.context_path = path.into();

        self
    }

    /// Set the default working directory inside the container (default "/app")
    pub fn with_workdir(&mut self, path: impl Into<PathBuf>) -> &mut Self {
        self.workdir = path.into();

        self
    }

    /// Instead of killing the container on drop, retain it for inspection. Default is false.
    pub fn retain_on_drop(&mut self, retain: bool) -> &mut Self {
        self.retain_on_drop = retain;

        self
    }

    /// Clear the environment variables before starting the service in the container
    pub fn clear_env(&mut self) -> &mut Self {
        self.env_clear = true;

        self
    }

    /// Remove an environment variable from the service in the container
    pub fn remove_env(&mut self, env: impl Into<String>) -> &mut Self {
        self.remove_env.push(env.into());

        self
    }

    /// Set an environment variable for the service in the container
    pub fn with_env(&mut self, key: impl Into<String>, value: impl Into<String>) -> &mut Self {
        self.env.insert(key.into(), value.into());

        self
    }

    /// Set multiple environment variables for the service in the container
    pub fn with_envs(&mut self, envs: impl Into<HashMap<String, String>>) -> &mut Self {
        self.env.extend(envs.into());

        self
    }

    /// Use the provided timeout as the default for every command executed against the container.
    pub fn with_default_timeout(&mut self, timeout: Duration) -> &mut Self {
        self.default_timeout = Some(timeout);

        self
    }

    /// Remove any default timeout previously configured on this executor.
    pub fn clear_default_timeout(&mut self) -> &mut Self {
        self.default_timeout = None;

        self
    }

    /// Set the user (or user_id:group_id) to run the container as (default None, which means root)
    pub fn with_user(&mut self, user: impl Into<String>) -> &mut Self {
        self.user = Some(user.into());

        self
    }

    /// Start with an existing image (full tag). Will skip building the image, unless you set a new
    /// Dockerfile. Note that this requires that the image has the service available as a binary.
    pub fn with_existing_image(&mut self, path: impl Into<String>) -> &mut Self {
        self.image_name = path.into();

        // If an existing image is used, we don't need to build it
        self.dockerfile = None;

        self
    }

    /// Set the name of the image to build (default "docker-executor")
    pub fn with_image_name(&mut self, name: impl Into<String>) -> &mut Self {
        self.image_name = name.into();

        self
    }

    /// Overwrite the uuid that is added as suffix to the running container
    pub fn with_container_uuid(&mut self, uuid: impl Into<Uuid>) -> &mut Self {
        self.container_uuid = uuid.into();

        self
    }

    /// Overwrite the dockerfile to use (default "Dockerfile")
    pub fn with_dockerfile(&mut self, path: impl Into<PathBuf>) -> &mut Self {
        self.dockerfile = Some(path.into());
        self
    }

    /// Starts the docker executor
    ///
    /// Note that on dropping the `RunningDockerExecutor`, the container will be stopped
    pub async fn start(self) -> Result<RunningDockerExecutor, DockerExecutorError> {
        RunningDockerExecutor::start(&self).await
    }
}