proxmox_api/generated/nodes/node/
services.rs

1pub mod service;
2#[derive(Debug, Clone)]
3pub struct ServicesClient<T> {
4    client: T,
5    path: String,
6}
7impl<T> ServicesClient<T>
8where
9    T: crate::client::Client,
10{
11    pub fn new(client: T, parent_path: &str) -> Self {
12        Self {
13            client,
14            path: format!("{}{}", parent_path, "/services"),
15        }
16    }
17}
18impl<T> ServicesClient<T>
19where
20    T: crate::client::Client,
21{
22    #[doc = "Service list."]
23    #[doc = ""]
24    #[doc = "Permission check: perm(\"/nodes/{node}\", [\"Sys.Audit\"])"]
25    pub async fn get(&self) -> Result<Vec<GetOutputItems>, T::Error> {
26        let path = self.path.to_string();
27        let optional_vec: Option<Vec<GetOutputItems>> = self.client.get(&path, &()).await?;
28        Ok(optional_vec.unwrap_or_default())
29    }
30}
31impl GetOutputItems {
32    pub fn new(
33        active_state: ActiveState,
34        desc: String,
35        name: String,
36        service: String,
37        state: State,
38        unit_state: UnitState,
39    ) -> Self {
40        Self {
41            active_state,
42            desc,
43            name,
44            service,
45            state,
46            unit_state,
47            additional_properties: ::std::default::Default::default(),
48        }
49    }
50}
51#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize)]
52pub struct GetOutputItems {
53    #[serde(rename = "active-state")]
54    #[doc = "Current state of the service process (systemd ActiveState)."]
55    #[doc = ""]
56    pub active_state: ActiveState,
57    #[doc = "Description of the service."]
58    #[doc = ""]
59    pub desc: String,
60    #[doc = "Short identifier for the service (e.g., \"pveproxy\")."]
61    #[doc = ""]
62    pub name: String,
63    #[doc = "Systemd unit name (e.g., pveproxy)."]
64    #[doc = ""]
65    pub service: String,
66    #[doc = "Execution status of the service (systemd SubState)."]
67    #[doc = ""]
68    pub state: State,
69    #[serde(rename = "unit-state")]
70    #[doc = "Whether the service is enabled (systemd UnitFileState)."]
71    #[doc = ""]
72    pub unit_state: UnitState,
73    #[serde(
74        flatten,
75        default,
76        skip_serializing_if = "::std::collections::HashMap::is_empty"
77    )]
78    pub additional_properties: ::std::collections::HashMap<String, ::serde_json::Value>,
79}
80#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
81#[doc = "Current state of the service process (systemd ActiveState)."]
82#[doc = ""]
83pub enum ActiveState {
84    #[serde(rename = "activating")]
85    Activating,
86    #[serde(rename = "active")]
87    Active,
88    #[serde(rename = "deactivating")]
89    Deactivating,
90    #[serde(rename = "failed")]
91    Failed,
92    #[serde(rename = "inactive")]
93    Inactive,
94    #[serde(rename = "maintenance")]
95    Maintenance,
96    #[serde(rename = "refreshing")]
97    Refreshing,
98    #[serde(rename = "reloading")]
99    Reloading,
100    #[serde(rename = "unknown")]
101    Unknown,
102}
103impl TryFrom<&str> for ActiveState {
104    type Error = String;
105    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
106        match value {
107            "activating" => Ok(Self::Activating),
108            "active" => Ok(Self::Active),
109            "deactivating" => Ok(Self::Deactivating),
110            "failed" => Ok(Self::Failed),
111            "inactive" => Ok(Self::Inactive),
112            "maintenance" => Ok(Self::Maintenance),
113            "refreshing" => Ok(Self::Refreshing),
114            "reloading" => Ok(Self::Reloading),
115            "unknown" => Ok(Self::Unknown),
116            v => Err(format!("Unknown variant {v}")),
117        }
118    }
119}
120#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
121#[doc = "Execution status of the service (systemd SubState)."]
122#[doc = ""]
123pub enum State {
124    #[serde(rename = "auto-restart")]
125    AutoRestart,
126    #[serde(rename = "auto-restart-queued")]
127    AutoRestartQueued,
128    #[serde(rename = "cleaning")]
129    Cleaning,
130    #[serde(rename = "condition")]
131    Condition,
132    #[serde(rename = "dead")]
133    Dead,
134    #[serde(rename = "dead-before-auto-restart")]
135    DeadBeforeAutoRestart,
136    #[serde(rename = "dead-resources-pinned")]
137    DeadResourcesPinned,
138    #[serde(rename = "exited")]
139    Exited,
140    #[serde(rename = "failed")]
141    Failed,
142    #[serde(rename = "failed-before-auto-restart")]
143    FailedBeforeAutoRestart,
144    #[serde(rename = "final-sigkill")]
145    FinalSigkill,
146    #[serde(rename = "final-sigterm")]
147    FinalSigterm,
148    #[serde(rename = "final-watchdog")]
149    FinalWatchdog,
150    #[serde(rename = "mounting")]
151    Mounting,
152    #[serde(rename = "reload")]
153    Reload,
154    #[serde(rename = "reload-notify")]
155    ReloadNotify,
156    #[serde(rename = "reload-signal")]
157    ReloadSignal,
158    #[serde(rename = "running")]
159    Running,
160    #[serde(rename = "start")]
161    Start,
162    #[serde(rename = "start-post")]
163    StartPost,
164    #[serde(rename = "start-pre")]
165    StartPre,
166    #[serde(rename = "stop")]
167    Stop,
168    #[serde(rename = "stop-post")]
169    StopPost,
170    #[serde(rename = "stop-sigkill")]
171    StopSigkill,
172    #[serde(rename = "stop-sigterm")]
173    StopSigterm,
174    #[serde(rename = "stop-watchdog")]
175    StopWatchdog,
176    #[serde(rename = "unknown")]
177    Unknown,
178}
179impl TryFrom<&str> for State {
180    type Error = String;
181    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
182        match value {
183            "auto-restart" => Ok(Self::AutoRestart),
184            "auto-restart-queued" => Ok(Self::AutoRestartQueued),
185            "cleaning" => Ok(Self::Cleaning),
186            "condition" => Ok(Self::Condition),
187            "dead" => Ok(Self::Dead),
188            "dead-before-auto-restart" => Ok(Self::DeadBeforeAutoRestart),
189            "dead-resources-pinned" => Ok(Self::DeadResourcesPinned),
190            "exited" => Ok(Self::Exited),
191            "failed" => Ok(Self::Failed),
192            "failed-before-auto-restart" => Ok(Self::FailedBeforeAutoRestart),
193            "final-sigkill" => Ok(Self::FinalSigkill),
194            "final-sigterm" => Ok(Self::FinalSigterm),
195            "final-watchdog" => Ok(Self::FinalWatchdog),
196            "mounting" => Ok(Self::Mounting),
197            "reload" => Ok(Self::Reload),
198            "reload-notify" => Ok(Self::ReloadNotify),
199            "reload-signal" => Ok(Self::ReloadSignal),
200            "running" => Ok(Self::Running),
201            "start" => Ok(Self::Start),
202            "start-post" => Ok(Self::StartPost),
203            "start-pre" => Ok(Self::StartPre),
204            "stop" => Ok(Self::Stop),
205            "stop-post" => Ok(Self::StopPost),
206            "stop-sigkill" => Ok(Self::StopSigkill),
207            "stop-sigterm" => Ok(Self::StopSigterm),
208            "stop-watchdog" => Ok(Self::StopWatchdog),
209            "unknown" => Ok(Self::Unknown),
210            v => Err(format!("Unknown variant {v}")),
211        }
212    }
213}
214#[derive(Clone, Debug, :: serde :: Serialize, :: serde :: Deserialize, PartialEq)]
215#[doc = "Whether the service is enabled (systemd UnitFileState)."]
216#[doc = ""]
217pub enum UnitState {
218    #[serde(rename = "alias")]
219    Alias,
220    #[serde(rename = "bad")]
221    Bad,
222    #[serde(rename = "disabled")]
223    Disabled,
224    #[serde(rename = "enabled")]
225    Enabled,
226    #[serde(rename = "enabled-runtime")]
227    EnabledRuntime,
228    #[serde(rename = "generated")]
229    Generated,
230    #[serde(rename = "indirect")]
231    Indirect,
232    #[serde(rename = "linked")]
233    Linked,
234    #[serde(rename = "linked-runtime")]
235    LinkedRuntime,
236    #[serde(rename = "masked")]
237    Masked,
238    #[serde(rename = "masked-runtime")]
239    MaskedRuntime,
240    #[serde(rename = "not-found")]
241    NotFound,
242    #[serde(rename = "static")]
243    Static,
244    #[serde(rename = "transient")]
245    Transient,
246    #[serde(rename = "unknown")]
247    Unknown,
248}
249impl TryFrom<&str> for UnitState {
250    type Error = String;
251    fn try_from(value: &str) -> Result<Self, <Self as TryFrom<&str>>::Error> {
252        match value {
253            "alias" => Ok(Self::Alias),
254            "bad" => Ok(Self::Bad),
255            "disabled" => Ok(Self::Disabled),
256            "enabled" => Ok(Self::Enabled),
257            "enabled-runtime" => Ok(Self::EnabledRuntime),
258            "generated" => Ok(Self::Generated),
259            "indirect" => Ok(Self::Indirect),
260            "linked" => Ok(Self::Linked),
261            "linked-runtime" => Ok(Self::LinkedRuntime),
262            "masked" => Ok(Self::Masked),
263            "masked-runtime" => Ok(Self::MaskedRuntime),
264            "not-found" => Ok(Self::NotFound),
265            "static" => Ok(Self::Static),
266            "transient" => Ok(Self::Transient),
267            "unknown" => Ok(Self::Unknown),
268            v => Err(format!("Unknown variant {v}")),
269        }
270    }
271}
272impl<T> ServicesClient<T>
273where
274    T: crate::client::Client,
275{
276    pub fn service(&self, service: &str) -> service::ServiceClient<T> {
277        service::ServiceClient::<T>::new(self.client.clone(), &self.path, service)
278    }
279}
proxmox_api/generated/nodes/node/services.rs

proxmox_api/generated/nodes/node/
services.rs
