Skip to main content

zombienet_provider/kubernetes/
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::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    // Pre-existing namespace to spawn into, instead of creating one.
29    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    /// Spawns into `namespace`, which must already exist. Zombienet won't create it
42    /// nor delete it on drop, but `destroy()` still deletes it.
43    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    /// Provider talking to `server`. Unmocked requests get mockito's 501, so
181    /// spawning fails right after the namespace step. kube appends a query string,
182    /// hence `match_query` on exact-path mocks.
183    fn provider(
184        server: &ServerGuard,
185        existing_namespace: Option<&str>,
186    ) -> Arc<KubernetesProvider<InMemoryFileSystem>> {
187        // In-memory `create_dir` needs every ancestor of the tmp dir to exist. Going
188        // through `components()` drops the trailing `/` `$TMPDIR` may have.
189        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}