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

pub mod container;
pub mod error;
pub mod image;

pub use bollard::{auth::DockerCredentials, Docker};

use crate::error::Result;
use crate::image::Image;
use std::io::Write;

pub struct McaiDocker {
  credentials: Option<DockerCredentials>,
  docker: Docker,
}

pub struct ConfigOptions {}

impl McaiDocker {
  pub fn new(docker: Docker) -> Self {
    McaiDocker {
      docker,
      credentials: None,
    }
  }

  pub fn with_credential(mut self, credentials: DockerCredentials) -> Self {
    self.credentials = Some(credentials);
    self
  }

  pub async fn describe_worker(
    &self,
    docker_image_name: &str,
    stream: Option<&mut (dyn Write + Send)>,
  ) -> Result<()> {
    let builder = Image::new(docker_image_name)
      .with_optional_credentials(self.credentials.clone())
      .build(&self.docker)
      .await?;
    let container = builder.with_env("DESCRIBE", &1).build(&self.docker).await?;
    container.run(&self.docker, stream).await?;
    container.remove(&self.docker, true).await
  }

  pub async fn run_worker_with_source_orders(
    &self,
    docker_image_name: &str,
    source_orders: &[&str],
    stream: Option<&mut (dyn Write + Send)>,
  ) -> Result<()> {
    self
      .run_worker(
        docker_image_name,
        &[("SOURCE_ORDERS", &source_orders.join(":"))],
        stream,
      )
      .await
  }

  pub async fn run_worker(
    &self,
    docker_image_name: &str,
    envs: &[(&str, &(dyn ToString + Send + Sync))],
    stream: Option<&mut (dyn Write + Send)>,
  ) -> Result<()> {
    let builder = Image::new(docker_image_name)
      .with_optional_credentials(self.credentials.clone())
      .build(&self.docker)
      .await?;

    let container = builder
      .with_enable_tty()
      .with_envs(envs)
      .build(&self.docker)
      .await?;
    container.run(&self.docker, stream).await?;
    container.remove(&self.docker, true).await
  }
}