Skip to main content

esh_providers_docker/
lib.rs

1//! Docker secrets provider (`/run/secrets` by default).
2
3use async_trait::async_trait;
4use esh_core::{
5    ConfigValue, Error, Provider, ProviderCapability, ProviderId, ProviderMeta, Result,
6};
7use std::path::{Path, PathBuf};
8
9/// Reads Docker Swarm / Compose secrets from a directory.
10pub struct DockerSecretsProvider {
11    meta: ProviderMeta,
12    root: PathBuf,
13}
14
15impl DockerSecretsProvider {
16    /// Use `/run/secrets`.
17    #[must_use]
18    pub fn default_path() -> Self {
19        Self::from_path("/run/secrets")
20    }
21
22    /// Custom secrets directory (useful in tests).
23    #[must_use]
24    pub fn from_path(path: impl AsRef<Path>) -> Self {
25        Self {
26            meta: ProviderMeta {
27                id: ProviderId::new("docker"),
28                name: "Docker Secrets".into(),
29                capabilities: ProviderCapability {
30                    bulk: true,
31                    versioned: false,
32                    local: true,
33                },
34            },
35            root: path.as_ref().to_path_buf(),
36        }
37    }
38}
39
40#[async_trait]
41impl Provider for DockerSecretsProvider {
42    fn meta(&self) -> &ProviderMeta {
43        &self.meta
44    }
45
46    async fn get(&self, key: &str) -> Result<ConfigValue> {
47        // Docker secret names often use underscores; also allow as-is filenames.
48        let path = self.root.join(key);
49        if !path.exists() {
50            return Err(Error::not_found(key));
51        }
52        let raw = tokio::fs::read_to_string(&path).await.map_err(|e| {
53            Error::provider(
54                self.meta.id.as_str(),
55                format!("failed to read {}: {e}", path.display()),
56            )
57        })?;
58        Ok(ConfigValue::secret(raw.trim_end().to_string()))
59    }
60
61    async fn health(&self) -> Result<()> {
62        if self.root.is_dir() {
63            Ok(())
64        } else {
65            Err(Error::ProviderUnavailable {
66                provider: self.meta.id.as_str().into(),
67            })
68        }
69    }
70}
71
72#[cfg(test)]
73mod tests {
74    use super::*;
75    use esh_test_support::{
76        run_provider_conformance, write_secret_dir, ProviderConformanceCfg, SAMPLE_TOKEN,
77    };
78
79    #[tokio::test]
80    async fn reads_secret_file() {
81        let dir = write_secret_dir(&[("db_password", "s3cret\n")]);
82        let p = DockerSecretsProvider::from_path(dir.path());
83        let v = p.get("db_password").await.unwrap();
84        assert_eq!(v.as_str(), Some("s3cret"));
85    }
86
87    #[tokio::test]
88    async fn docker_conformance() {
89        let dir = write_secret_dir(&[("api_token", SAMPLE_TOKEN)]);
90        let p = DockerSecretsProvider::from_path(dir.path());
91        run_provider_conformance(
92            &p,
93            &ProviderConformanceCfg {
94                expected_id: "docker".into(),
95                expected_capabilities: ProviderCapability {
96                    bulk: true,
97                    versioned: false,
98                    local: true,
99                },
100                present_key: "api_token".into(),
101                present_value: SAMPLE_TOKEN.into(),
102                missing_key: "missing".into(),
103                fault_key: None,
104                health_ok: true,
105                test_get_many: true,
106            },
107        )
108        .await;
109    }
110}