proxmox_api/generated/nodes/node/services/service/
state.rs

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

proxmox_api/generated/nodes/node/services/service/
state.rs
