Skip to main content

esh_providers_k8s/
lib.rs

1//! Kubernetes secrets via projected / mounted secret volumes.
2//!
3//! Default root: `/var/run/secrets/esh` (configurable). Also supports flat
4//! key files under a directory (common with `secretKeyRef` volume mounts).
5
6use async_trait::async_trait;
7use esh_core::{
8    ConfigValue, Error, Provider, ProviderCapability, ProviderId, ProviderMeta, Result,
9};
10use std::path::{Path, PathBuf};
11
12/// File-based Kubernetes secrets provider.
13pub struct KubernetesSecretsProvider {
14    meta: ProviderMeta,
15    root: PathBuf,
16}
17
18impl KubernetesSecretsProvider {
19    /// Default mount path used by ESH conventions.
20    #[must_use]
21    pub fn default_path() -> Self {
22        Self::from_path("/var/run/secrets/esh")
23    }
24
25    /// Custom mount directory.
26    #[must_use]
27    pub fn from_path(path: impl AsRef<Path>) -> Self {
28        Self {
29            meta: ProviderMeta {
30                id: ProviderId::new("kubernetes"),
31                name: "Kubernetes Secrets".into(),
32                capabilities: ProviderCapability {
33                    bulk: true,
34                    versioned: false,
35                    local: true,
36                },
37            },
38            root: path.as_ref().to_path_buf(),
39        }
40    }
41}
42
43#[async_trait]
44impl Provider for KubernetesSecretsProvider {
45    fn meta(&self) -> &ProviderMeta {
46        &self.meta
47    }
48
49    async fn get(&self, key: &str) -> Result<ConfigValue> {
50        let path = self.root.join(key);
51        if !path.exists() {
52            return Err(Error::not_found(key));
53        }
54        let raw = tokio::fs::read_to_string(&path).await.map_err(|e| {
55            Error::provider(
56                self.meta.id.as_str(),
57                format!("failed to read {}: {e}", path.display()),
58            )
59        })?;
60        Ok(ConfigValue::secret(raw.trim_end().to_string()))
61    }
62
63    async fn health(&self) -> Result<()> {
64        if self.root.is_dir()
65            || std::path::Path::new("/var/run/secrets/kubernetes.io").exists()
66            || std::env::var_os("KUBERNETES_SERVICE_HOST").is_some()
67        {
68            Ok(())
69        } else {
70            Err(Error::ProviderUnavailable {
71                provider: self.meta.id.as_str().into(),
72            })
73        }
74    }
75}
76
77#[cfg(test)]
78mod tests {
79    use super::*;
80    use esh_test_support::{
81        run_provider_conformance, write_secret_dir, ProviderConformanceCfg, SAMPLE_TOKEN,
82    };
83
84    #[tokio::test]
85    async fn reads_mounted_secret() {
86        let dir = write_secret_dir(&[("api_token", "k8s-token")]);
87        let p = KubernetesSecretsProvider::from_path(dir.path());
88        assert_eq!(p.get("api_token").await.unwrap().as_str(), Some("k8s-token"));
89    }
90
91    #[tokio::test]
92    async fn k8s_conformance() {
93        let dir = write_secret_dir(&[("api_token", SAMPLE_TOKEN)]);
94        let p = KubernetesSecretsProvider::from_path(dir.path());
95        run_provider_conformance(
96            &p,
97            &ProviderConformanceCfg {
98                expected_id: "kubernetes".into(),
99                expected_capabilities: ProviderCapability {
100                    bulk: true,
101                    versioned: false,
102                    local: true,
103                },
104                present_key: "api_token".into(),
105                present_value: SAMPLE_TOKEN.into(),
106                missing_key: "missing".into(),
107                fault_key: None,
108                health_ok: true,
109                test_get_many: true,
110            },
111        )
112        .await;
113    }
114}