pupoxide 0.2.3

A high-performance, memory-safe, declarative configuration management tool inspired by Puppet.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use crate::domain::error::Result;
use crate::domain::resource::{Ensure, Resource, ResourceProvider, ResourceState};
use async_trait::async_trait;
use std::collections::HashMap;
use std::sync::Arc;

pub mod brew;

#[async_trait]
pub trait PackageProvider: Send + Sync {
    /// Returns the provider name (e.g., "brew", "apt")
    fn name(&self) -> &str;

    /// Returns true if the package is currently installed
    async fn is_installed(&self, package_name: &str) -> Result<bool>;

    /// Installs the package
    async fn install(&self, package_name: &str) -> Result<()>;

    /// Uninstalls the package
    async fn uninstall(&self, package_name: &str) -> Result<()>;
}

pub struct PackageAdapter {
    providers: HashMap<String, Arc<dyn PackageProvider>>,
}

impl Default for PackageAdapter {
    fn default() -> Self {
        Self::new().with_provider(Arc::new(brew::BrewProvider))
    }
}

impl PackageAdapter {
    pub fn new() -> Self {
        Self {
            providers: HashMap::new(),
        }
    }

    pub fn with_provider(mut self, provider: Arc<dyn PackageProvider>) -> Self {
        self.providers.insert(provider.name().to_string(), provider);
        self
    }

    async fn get_provider(&self, name: &str) -> Result<&Arc<dyn PackageProvider>> {
        self.providers
            .get(name)
            .ok_or_else(|| anyhow::anyhow!("Package provider '{}' not found", name))
    }
}

#[async_trait]
impl ResourceProvider for PackageAdapter {
    fn can_handle(&self, resource: &Resource) -> bool {
        matches!(resource, Resource::Package(_))
    }

    async fn get_state(&self, resource: &Resource, _full: bool) -> Result<ResourceState> {
        match resource {
            Resource::Package(pkg) => {
                let provider = self.get_provider(&pkg.provider).await?;
                let is_installed = provider.is_installed(&pkg.name).await?;
                let ensure = if is_installed {
                    Ensure::Present
                } else {
                    Ensure::Absent
                };
                Ok(ResourceState::Ensure(ensure))
            }
            _ => Ok(ResourceState::Ensure(Ensure::Present)),
        }
    }

    async fn apply(&self, resource: &Resource) -> Result<()> {
        match resource {
            Resource::Package(pkg) => {
                let provider = self.get_provider(&pkg.provider).await?;
                let is_installed = provider.is_installed(&pkg.name).await?;

                match (&pkg.ensure, is_installed) {
                    (Ensure::Present, false) => {
                        tracing::info!(package = %pkg.name, provider = %pkg.provider, "Installing package");
                        provider.install(&pkg.name).await
                    }
                    (Ensure::Absent, true) => {
                        tracing::info!(package = %pkg.name, provider = %pkg.provider, "Uninstalling package");
                        provider.uninstall(&pkg.name).await
                    }
                    _ => {
                        tracing::debug!(package = %pkg.name, ensure = ?pkg.ensure, "Package already in desired state");
                        Ok(())
                    }
                }
            }
            _ => Ok(()),
        }
    }
}