zombienet_provider/docker/
provider.rs1use 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 let _ = ns.destroy().await;
61 }
62 }
63
64 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}