pupoxide 0.2.0

A high-performance, memory-safe, declarative configuration management tool inspired by Puppet.
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use crate::domain::error::Result;
use serde::{Deserialize, Serialize};
use std::path::PathBuf;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
#[derive(Default)]
pub enum Ensure {
    #[default]
    Present,
    Absent,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum ResourceState {
    Ensure(Ensure),
    /// Current state including content
    Full {
        ensure: Ensure,
        content: Option<Vec<u8>>,
    },
}



#[derive(Debug, Clone, Serialize, Deserialize, validator::Validate, PartialEq)]
pub struct FileResource {
    pub id: String,
    pub path: PathBuf,
    pub ensure: Ensure,
    pub content: Option<String>,
    pub dependencies: Vec<String>,
    pub owner: Option<String>,
    pub group: Option<String>,
    pub mode: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum MetaKind {
    ModuleStart,
    ModuleEnd,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MetaResource {
    pub id: String,
    pub kind: MetaKind,
    pub dependencies: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, validator::Validate)]
pub struct ExecResource {
    pub id: String,
    pub command: String,
    pub creates: Option<PathBuf>,
    pub unless: Option<String>,
    pub cwd: Option<PathBuf>,
    pub environment: Option<std::collections::HashMap<String, String>>,
    pub dependencies: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, validator::Validate)]
pub struct DirectoryResource {
    pub id: String,
    pub path: PathBuf,
    pub ensure: Ensure,
    pub dependencies: Vec<String>,
    pub owner: Option<String>,
    pub group: Option<String>,
    pub mode: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum Resource {
    File(FileResource),
    Directory(DirectoryResource),
    Exec(ExecResource),
    Meta(MetaResource),
}

impl Resource {
    pub fn id(&self) -> &str {
        match self {
            Resource::File(f) => &f.id,
            Resource::Directory(d) => &d.id,
            Resource::Exec(e) => &e.id,
            Resource::Meta(m) => &m.id,
        }
    }

    pub fn dependencies(&self) -> &[String] {
        match self {
            Resource::File(f) => &f.dependencies,
            Resource::Directory(d) => &d.dependencies,
            Resource::Exec(e) => &e.dependencies,
            Resource::Meta(m) => &m.dependencies,
        }
    }

    pub fn add_dependency(&mut self, dep_id: String) {
        match self {
            Resource::File(f) => {
                if !f.dependencies.contains(&dep_id) {
                    f.dependencies.push(dep_id);
                }
            }
            Resource::Directory(d) => {
                if !d.dependencies.contains(&dep_id) {
                    d.dependencies.push(dep_id);
                }
            }
            Resource::Exec(e) => {
                if !e.dependencies.contains(&dep_id) {
                    e.dependencies.push(dep_id);
                }
            }
            Resource::Meta(m) => {
                if !m.dependencies.contains(&dep_id) {
                    m.dependencies.push(dep_id);
                }
            }
        }
    }
}

/// The Port for resource providers.
/// Every adapter (Infrastructure) must implement this to handle specific resource types.
#[async_trait::async_trait]
pub trait ResourceProvider: Send + Sync {
    /// Returns true if this provider can handle the given resource
    fn can_handle(&self, resource: &Resource) -> bool;

    /// Returns the current state of the resource on the system.
    /// If full is true, the provider SHOULD attempt to return the full content.
    async fn get_state(&self, resource: &Resource, full: bool) -> Result<ResourceState>;

    /// Applies the desired state to the system
    async fn apply(&self, resource: &Resource) -> Result<()>;
}