Skip to main content

zombienet_provider/docker/
provider.rs

1use std::{
2    collections::HashMap,
3    path::{Path, PathBuf},
4    sync::{Arc, Weak},
5};
6
7use async_trait::async_trait;
8use support::fs::FileSystem;
9use tokio::sync::RwLock;
10
11use super::{client::DockerClient, namespace::DockerNamespace};
12use crate::{
13    shared::helpers::extract_namespace_info, types::ProviderCapabilities, DynNamespace, Provider,
14    ProviderError, ProviderNamespace,
15};
16
17pub const PROVIDER_NAME: &str = "docker";
18
19pub struct DockerProvider<FS>
20where
21    FS: FileSystem + Send + Sync + Clone,
22{
23    weak: Weak<DockerProvider<FS>>,
24    capabilities: ProviderCapabilities,
25    tmp_dir: PathBuf,
26    docker_client: DockerClient,
27    filesystem: FS,
28    pub(super) namespaces: RwLock<HashMap<String, Arc<DockerNamespace<FS>>>>,
29}
30
31impl<FS> DockerProvider<FS>
32where
33    FS: FileSystem + Send + Sync + Clone + 'static,
34{
35    pub async fn new(filesystem: FS) -> Arc<Self> {
36        let docker_client = DockerClient::new().await.unwrap();
37
38        let provider = Arc::new_cyclic(|weak| DockerProvider {
39            weak: weak.clone(),
40            capabilities: ProviderCapabilities {
41                requires_image: true,
42                has_resources: false,
43                prefix_with_full_path: false,
44                use_default_ports_in_cmd: true,
45                has_secrets: false,
46                fileserver_fetches_db_snapshot_url: false,
47            },
48            tmp_dir: std::env::temp_dir(),
49            docker_client,
50            filesystem,
51            namespaces: RwLock::new(HashMap::new()),
52        });
53
54        let cloned_provider = provider.clone();
55        tokio::spawn(async move {
56            tokio::signal::ctrl_c().await.unwrap();
57            for (_, ns) in cloned_provider.namespaces().await {
58                if ns.is_detached().await {
59                    // best effort
60                    let _ = ns.destroy().await;
61                }
62            }
63
64            // exit the process (130, SIGINT)
65            std::process::exit(130)
66        });
67
68        provider
69    }
70
71    pub fn tmp_dir(mut self, tmp_dir: impl Into<PathBuf>) -> Self {
72        self.tmp_dir = tmp_dir.into();
73        self
74    }
75}
76
77#[async_trait]
78impl<FS> Provider for DockerProvider<FS>
79where
80    FS: FileSystem + Send + Sync + Clone + 'static,
81{
82    fn name(&self) -> &str {
83        PROVIDER_NAME
84    }
85
86    fn capabilities(&self) -> &ProviderCapabilities {
87        &self.capabilities
88    }
89
90    async fn namespaces(&self) -> HashMap<String, DynNamespace> {
91        self.namespaces
92            .read()
93            .await
94            .iter()
95            .map(|(name, namespace)| (name.clone(), namespace.clone() as DynNamespace))
96            .collect()
97    }
98
99    async fn create_namespace(&self) -> Result<DynNamespace, ProviderError> {
100        let namespace = DockerNamespace::new(
101            &self.weak,
102            &self.tmp_dir,
103            &self.capabilities,
104            &self.docker_client,
105            &self.filesystem,
106            None,
107        )
108        .await?;
109
110        self.namespaces
111            .write()
112            .await
113            .insert(namespace.name().to_string(), namespace.clone());
114
115        Ok(namespace)
116    }
117
118    async fn create_namespace_with_base_dir(
119        &self,
120        base_dir: &Path,
121    ) -> Result<DynNamespace, ProviderError> {
122        let namespace = DockerNamespace::new(
123            &self.weak,
124            &self.tmp_dir,
125            &self.capabilities,
126            &self.docker_client,
127            &self.filesystem,
128            Some(base_dir),
129        )
130        .await?;
131
132        self.namespaces
133            .write()
134            .await
135            .insert(namespace.name().to_string(), namespace.clone());
136
137        Ok(namespace)
138    }
139
140    async fn create_namespace_from_json(
141        &self,
142        json_value: &serde_json::Value,
143    ) -> Result<DynNamespace, ProviderError> {
144        let (base_dir, name) = extract_namespace_info(json_value)?;
145
146        let namespace = DockerNamespace::attach_to_live(
147            &self.weak,
148            &self.capabilities,
149            &self.docker_client,
150            &self.filesystem,
151            &base_dir,
152            &name,
153        )
154        .await?;
155
156        self.namespaces
157            .write()
158            .await
159            .insert(namespace.name().to_string(), namespace.clone());
160
161        Ok(namespace)
162    }
163}