zombienet_provider/kubernetes/
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::KubernetesClient, namespace::KubernetesNamespace};
12use crate::{
13 shared::helpers::extract_namespace_info, types::ProviderCapabilities, DynNamespace, Provider,
14 ProviderError, ProviderNamespace,
15};
16
17pub const PROVIDER_NAME: &str = "k8s";
18
19pub struct KubernetesProvider<FS>
20where
21 FS: FileSystem + Send + Sync + Clone,
22{
23 weak: Weak<KubernetesProvider<FS>>,
24 capabilities: ProviderCapabilities,
25 tmp_dir: PathBuf,
26 k8s_client: KubernetesClient,
27 filesystem: FS,
28 existing_namespace: Option<String>,
30 pub(super) namespaces: RwLock<HashMap<String, Arc<KubernetesNamespace<FS>>>>,
31}
32
33impl<FS> KubernetesProvider<FS>
34where
35 FS: FileSystem + Send + Sync + Clone,
36{
37 pub async fn new(filesystem: FS) -> Arc<Self> {
38 Self::build(filesystem, None).await
39 }
40
41 pub async fn new_in_namespace(filesystem: FS, namespace: impl Into<String>) -> Arc<Self> {
44 Self::build(filesystem, Some(namespace.into())).await
45 }
46
47 async fn build(filesystem: FS, existing_namespace: Option<String>) -> Arc<Self> {
48 let k8s_client = KubernetesClient::new().await.unwrap();
49 Self::with_client(filesystem, k8s_client, existing_namespace)
50 }
51
52 fn with_client(
53 filesystem: FS,
54 k8s_client: KubernetesClient,
55 existing_namespace: Option<String>,
56 ) -> Arc<Self> {
57 Arc::new_cyclic(|weak| KubernetesProvider {
58 weak: weak.clone(),
59 capabilities: ProviderCapabilities {
60 requires_image: true,
61 has_resources: true,
62 prefix_with_full_path: false,
63 use_default_ports_in_cmd: true,
64 has_secrets: true,
65 fileserver_fetches_db_snapshot_url: true,
66 },
67 tmp_dir: std::env::temp_dir(),
68 k8s_client,
69 filesystem,
70 existing_namespace,
71 namespaces: RwLock::new(HashMap::new()),
72 })
73 }
74
75 pub fn tmp_dir(mut self, tmp_dir: impl Into<PathBuf>) -> Self {
76 self.tmp_dir = tmp_dir.into();
77 self
78 }
79}
80
81#[async_trait]
82impl<FS> Provider for KubernetesProvider<FS>
83where
84 FS: FileSystem + Send + Sync + Clone + 'static,
85{
86 fn name(&self) -> &str {
87 PROVIDER_NAME
88 }
89
90 fn capabilities(&self) -> &ProviderCapabilities {
91 &self.capabilities
92 }
93
94 async fn namespaces(&self) -> HashMap<String, DynNamespace> {
95 self.namespaces
96 .read()
97 .await
98 .iter()
99 .map(|(name, namespace)| (name.clone(), namespace.clone() as DynNamespace))
100 .collect()
101 }
102
103 async fn create_namespace(&self) -> Result<DynNamespace, ProviderError> {
104 let namespace = KubernetesNamespace::new(
105 &self.weak,
106 &self.tmp_dir,
107 &self.capabilities,
108 &self.k8s_client,
109 &self.filesystem,
110 None,
111 self.existing_namespace.as_deref(),
112 )
113 .await?;
114
115 self.namespaces
116 .write()
117 .await
118 .insert(namespace.name().to_string(), namespace.clone());
119
120 Ok(namespace)
121 }
122
123 async fn create_namespace_with_base_dir(
124 &self,
125 base_dir: &Path,
126 ) -> Result<DynNamespace, ProviderError> {
127 let namespace = KubernetesNamespace::new(
128 &self.weak,
129 &self.tmp_dir,
130 &self.capabilities,
131 &self.k8s_client,
132 &self.filesystem,
133 Some(base_dir),
134 self.existing_namespace.as_deref(),
135 )
136 .await?;
137
138 self.namespaces
139 .write()
140 .await
141 .insert(namespace.name().to_string(), namespace.clone());
142
143 Ok(namespace)
144 }
145
146 async fn create_namespace_from_json(
147 &self,
148 json_value: &serde_json::Value,
149 ) -> Result<DynNamespace, ProviderError> {
150 let (base_dir, name) = extract_namespace_info(json_value)?;
151
152 let namespace = KubernetesNamespace::attach_to_live(
153 &self.weak,
154 &self.capabilities,
155 &self.k8s_client,
156 &self.filesystem,
157 &base_dir,
158 &name,
159 )
160 .await?;
161
162 self.namespaces
163 .write()
164 .await
165 .insert(namespace.name().to_string(), namespace.clone());
166
167 Ok(namespace)
168 }
169}
170
171#[cfg(test)]
172mod tests {
173 use std::{collections::HashMap, ffi::OsString};
174
175 use mockito::{Matcher, Mock, Server, ServerGuard};
176 use support::fs::in_memory::{InMemoryFile, InMemoryFileSystem};
177
178 use super::*;
179
180 fn provider(
184 server: &ServerGuard,
185 existing_namespace: Option<&str>,
186 ) -> Arc<KubernetesProvider<InMemoryFileSystem>> {
187 let tmp_dir: PathBuf = std::env::temp_dir().components().collect();
190 let files: HashMap<OsString, InMemoryFile> = tmp_dir
191 .ancestors()
192 .map(|dir| (dir.as_os_str().to_owned(), InMemoryFile::dir()))
193 .collect();
194 let config = kube::Config::new(server.url().parse().unwrap());
195 let client = KubernetesClient::from_inner(kube::Client::try_from(config).unwrap());
196
197 KubernetesProvider::with_client(
198 InMemoryFileSystem::new(files),
199 client,
200 existing_namespace.map(String::from),
201 )
202 }
203
204 async fn mock_create_namespace(server: &mut ServerGuard, times: usize) -> Mock {
205 server
206 .mock("POST", "/api/v1/namespaces")
207 .match_query(Matcher::Any)
208 .with_status(201)
209 .with_body(r#"{"apiVersion":"v1","kind":"Namespace","metadata":{"name":"mock"}}"#)
210 .expect(times)
211 .create_async()
212 .await
213 }
214
215 async fn mock_delete_namespace(server: &mut ServerGuard, path: Matcher, times: usize) -> Mock {
216 server
217 .mock("DELETE", path)
218 .with_status(200)
219 .expect(times)
220 .create_async()
221 .await
222 }
223
224 #[tokio::test(flavor = "multi_thread")]
225 async fn existing_namespace_is_neither_created_nor_deleted() {
226 let mut server = Server::new_async().await;
227 let create = mock_create_namespace(&mut server, 0).await;
228 let delete = mock_delete_namespace(&mut server, Matcher::Any, 0).await;
229 let file_server = server
230 .mock("POST", "/api/v1/namespaces/adopted/pods")
231 .match_query(Matcher::Any)
232 .with_status(500)
233 .create_async()
234 .await;
235
236 let provider = provider(&server, Some("adopted"));
237 assert!(provider.create_namespace().await.is_err());
238 drop(provider);
239
240 file_server.assert_async().await;
241 create.assert_async().await;
242 delete.assert_async().await;
243 }
244
245 #[tokio::test(flavor = "multi_thread")]
246 async fn own_namespace_is_created_and_deleted_on_drop() {
247 let mut server = Server::new_async().await;
248 let create = mock_create_namespace(&mut server, 1).await;
249 let delete = mock_delete_namespace(
250 &mut server,
251 Matcher::Regex("^/api/v1/namespaces/zombie-".into()),
252 1,
253 )
254 .await;
255
256 let provider = provider(&server, None);
257 assert!(provider.create_namespace().await.is_err());
258 drop(provider);
259
260 create.assert_async().await;
261 delete.assert_async().await;
262 }
263}