clientapi_pve/apis/
nodes_ceph_api.rs

1/*
2 * Proxmox Virtual Environment API
3 *
4 * Generated from apidoc.js. NOT an official Proxmox specification. See https://pve.proxmox.com/pve-docs/api-viewer/ for the upstream documentation.
5 *
6 * The version of the OpenAPI document: 9.x
7 * 
8 * Generated by: https://openapi-generator.tech
9 */
10
11
12use reqwest;
13use serde::{Deserialize, Serialize, de::Error as _};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration, ContentType};
16
17
18/// struct for typed errors of method [`nodes_ceph_cmd_safety`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum NodesCephCmdSafetyError {
22    Status400(models::PveError),
23    Status401(models::PveError),
24    Status403(models::PveError),
25    Status404(models::PveError),
26    Status500(models::PveError),
27    Status501(models::PveError),
28    Status503(models::PveError),
29    UnknownValue(serde_json::Value),
30}
31
32/// struct for typed errors of method [`nodes_ceph_createfs`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum NodesCephCreatefsError {
36    Status400(models::PveError),
37    Status401(models::PveError),
38    Status403(models::PveError),
39    Status404(models::PveError),
40    Status500(models::PveError),
41    Status501(models::PveError),
42    Status503(models::PveError),
43    UnknownValue(serde_json::Value),
44}
45
46/// struct for typed errors of method [`nodes_ceph_createmds`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum NodesCephCreatemdsError {
50    Status400(models::PveError),
51    Status401(models::PveError),
52    Status403(models::PveError),
53    Status404(models::PveError),
54    Status500(models::PveError),
55    Status501(models::PveError),
56    Status503(models::PveError),
57    UnknownValue(serde_json::Value),
58}
59
60/// struct for typed errors of method [`nodes_ceph_createmgr`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum NodesCephCreatemgrError {
64    Status400(models::PveError),
65    Status401(models::PveError),
66    Status403(models::PveError),
67    Status404(models::PveError),
68    Status500(models::PveError),
69    Status501(models::PveError),
70    Status503(models::PveError),
71    UnknownValue(serde_json::Value),
72}
73
74/// struct for typed errors of method [`nodes_ceph_createmon`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum NodesCephCreatemonError {
78    Status400(models::PveError),
79    Status401(models::PveError),
80    Status403(models::PveError),
81    Status404(models::PveError),
82    Status500(models::PveError),
83    Status501(models::PveError),
84    Status503(models::PveError),
85    UnknownValue(serde_json::Value),
86}
87
88/// struct for typed errors of method [`nodes_ceph_createosd`]
89#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum NodesCephCreateosdError {
92    Status400(models::PveError),
93    Status401(models::PveError),
94    Status403(models::PveError),
95    Status404(models::PveError),
96    Status500(models::PveError),
97    Status501(models::PveError),
98    Status503(models::PveError),
99    UnknownValue(serde_json::Value),
100}
101
102/// struct for typed errors of method [`nodes_ceph_createpool`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum NodesCephCreatepoolError {
106    Status400(models::PveError),
107    Status401(models::PveError),
108    Status403(models::PveError),
109    Status404(models::PveError),
110    Status500(models::PveError),
111    Status501(models::PveError),
112    Status503(models::PveError),
113    UnknownValue(serde_json::Value),
114}
115
116/// struct for typed errors of method [`nodes_ceph_crush`]
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum NodesCephCrushError {
120    Status400(models::PveError),
121    Status401(models::PveError),
122    Status403(models::PveError),
123    Status404(models::PveError),
124    Status500(models::PveError),
125    Status501(models::PveError),
126    Status503(models::PveError),
127    UnknownValue(serde_json::Value),
128}
129
130/// struct for typed errors of method [`nodes_ceph_db`]
131#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum NodesCephDbError {
134    Status400(models::PveError),
135    Status401(models::PveError),
136    Status403(models::PveError),
137    Status404(models::PveError),
138    Status500(models::PveError),
139    Status501(models::PveError),
140    Status503(models::PveError),
141    UnknownValue(serde_json::Value),
142}
143
144/// struct for typed errors of method [`nodes_ceph_destroyfs`]
145#[derive(Debug, Clone, Serialize, Deserialize)]
146#[serde(untagged)]
147pub enum NodesCephDestroyfsError {
148    Status400(models::PveError),
149    Status401(models::PveError),
150    Status403(models::PveError),
151    Status404(models::PveError),
152    Status500(models::PveError),
153    Status501(models::PveError),
154    Status503(models::PveError),
155    UnknownValue(serde_json::Value),
156}
157
158/// struct for typed errors of method [`nodes_ceph_destroymds`]
159#[derive(Debug, Clone, Serialize, Deserialize)]
160#[serde(untagged)]
161pub enum NodesCephDestroymdsError {
162    Status400(models::PveError),
163    Status401(models::PveError),
164    Status403(models::PveError),
165    Status404(models::PveError),
166    Status500(models::PveError),
167    Status501(models::PveError),
168    Status503(models::PveError),
169    UnknownValue(serde_json::Value),
170}
171
172/// struct for typed errors of method [`nodes_ceph_destroymgr`]
173#[derive(Debug, Clone, Serialize, Deserialize)]
174#[serde(untagged)]
175pub enum NodesCephDestroymgrError {
176    Status400(models::PveError),
177    Status401(models::PveError),
178    Status403(models::PveError),
179    Status404(models::PveError),
180    Status500(models::PveError),
181    Status501(models::PveError),
182    Status503(models::PveError),
183    UnknownValue(serde_json::Value),
184}
185
186/// struct for typed errors of method [`nodes_ceph_destroymon`]
187#[derive(Debug, Clone, Serialize, Deserialize)]
188#[serde(untagged)]
189pub enum NodesCephDestroymonError {
190    Status400(models::PveError),
191    Status401(models::PveError),
192    Status403(models::PveError),
193    Status404(models::PveError),
194    Status500(models::PveError),
195    Status501(models::PveError),
196    Status503(models::PveError),
197    UnknownValue(serde_json::Value),
198}
199
200/// struct for typed errors of method [`nodes_ceph_destroyosd`]
201#[derive(Debug, Clone, Serialize, Deserialize)]
202#[serde(untagged)]
203pub enum NodesCephDestroyosdError {
204    Status400(models::PveError),
205    Status401(models::PveError),
206    Status403(models::PveError),
207    Status404(models::PveError),
208    Status500(models::PveError),
209    Status501(models::PveError),
210    Status503(models::PveError),
211    UnknownValue(serde_json::Value),
212}
213
214/// struct for typed errors of method [`nodes_ceph_destroypool`]
215#[derive(Debug, Clone, Serialize, Deserialize)]
216#[serde(untagged)]
217pub enum NodesCephDestroypoolError {
218    Status400(models::PveError),
219    Status401(models::PveError),
220    Status403(models::PveError),
221    Status404(models::PveError),
222    Status500(models::PveError),
223    Status501(models::PveError),
224    Status503(models::PveError),
225    UnknownValue(serde_json::Value),
226}
227
228/// struct for typed errors of method [`nodes_ceph_get_ceph`]
229#[derive(Debug, Clone, Serialize, Deserialize)]
230#[serde(untagged)]
231pub enum NodesCephGetCephError {
232    Status400(models::PveError),
233    Status401(models::PveError),
234    Status403(models::PveError),
235    Status404(models::PveError),
236    Status500(models::PveError),
237    Status501(models::PveError),
238    Status503(models::PveError),
239    UnknownValue(serde_json::Value),
240}
241
242/// struct for typed errors of method [`nodes_ceph_get_cfg`]
243#[derive(Debug, Clone, Serialize, Deserialize)]
244#[serde(untagged)]
245pub enum NodesCephGetCfgError {
246    Status400(models::PveError),
247    Status401(models::PveError),
248    Status403(models::PveError),
249    Status404(models::PveError),
250    Status500(models::PveError),
251    Status501(models::PveError),
252    Status503(models::PveError),
253    UnknownValue(serde_json::Value),
254}
255
256/// struct for typed errors of method [`nodes_ceph_get_fs`]
257#[derive(Debug, Clone, Serialize, Deserialize)]
258#[serde(untagged)]
259pub enum NodesCephGetFsError {
260    Status400(models::PveError),
261    Status401(models::PveError),
262    Status403(models::PveError),
263    Status404(models::PveError),
264    Status500(models::PveError),
265    Status501(models::PveError),
266    Status503(models::PveError),
267    UnknownValue(serde_json::Value),
268}
269
270/// struct for typed errors of method [`nodes_ceph_get_mds`]
271#[derive(Debug, Clone, Serialize, Deserialize)]
272#[serde(untagged)]
273pub enum NodesCephGetMdsError {
274    Status400(models::PveError),
275    Status401(models::PveError),
276    Status403(models::PveError),
277    Status404(models::PveError),
278    Status500(models::PveError),
279    Status501(models::PveError),
280    Status503(models::PveError),
281    UnknownValue(serde_json::Value),
282}
283
284/// struct for typed errors of method [`nodes_ceph_get_mgr`]
285#[derive(Debug, Clone, Serialize, Deserialize)]
286#[serde(untagged)]
287pub enum NodesCephGetMgrError {
288    Status400(models::PveError),
289    Status401(models::PveError),
290    Status403(models::PveError),
291    Status404(models::PveError),
292    Status500(models::PveError),
293    Status501(models::PveError),
294    Status503(models::PveError),
295    UnknownValue(serde_json::Value),
296}
297
298/// struct for typed errors of method [`nodes_ceph_get_osd`]
299#[derive(Debug, Clone, Serialize, Deserialize)]
300#[serde(untagged)]
301pub enum NodesCephGetOsdError {
302    Status400(models::PveError),
303    Status401(models::PveError),
304    Status403(models::PveError),
305    Status404(models::PveError),
306    Status500(models::PveError),
307    Status501(models::PveError),
308    Status503(models::PveError),
309    UnknownValue(serde_json::Value),
310}
311
312/// struct for typed errors of method [`nodes_ceph_getpool`]
313#[derive(Debug, Clone, Serialize, Deserialize)]
314#[serde(untagged)]
315pub enum NodesCephGetpoolError {
316    Status400(models::PveError),
317    Status401(models::PveError),
318    Status403(models::PveError),
319    Status404(models::PveError),
320    Status500(models::PveError),
321    Status501(models::PveError),
322    Status503(models::PveError),
323    UnknownValue(serde_json::Value),
324}
325
326/// struct for typed errors of method [`nodes_ceph_in`]
327#[derive(Debug, Clone, Serialize, Deserialize)]
328#[serde(untagged)]
329pub enum NodesCephInError {
330    Status400(models::PveError),
331    Status401(models::PveError),
332    Status403(models::PveError),
333    Status404(models::PveError),
334    Status500(models::PveError),
335    Status501(models::PveError),
336    Status503(models::PveError),
337    UnknownValue(serde_json::Value),
338}
339
340/// struct for typed errors of method [`nodes_ceph_init`]
341#[derive(Debug, Clone, Serialize, Deserialize)]
342#[serde(untagged)]
343pub enum NodesCephInitError {
344    Status400(models::PveError),
345    Status401(models::PveError),
346    Status403(models::PveError),
347    Status404(models::PveError),
348    Status500(models::PveError),
349    Status501(models::PveError),
350    Status503(models::PveError),
351    UnknownValue(serde_json::Value),
352}
353
354/// struct for typed errors of method [`nodes_ceph_listmon`]
355#[derive(Debug, Clone, Serialize, Deserialize)]
356#[serde(untagged)]
357pub enum NodesCephListmonError {
358    Status400(models::PveError),
359    Status401(models::PveError),
360    Status403(models::PveError),
361    Status404(models::PveError),
362    Status500(models::PveError),
363    Status501(models::PveError),
364    Status503(models::PveError),
365    UnknownValue(serde_json::Value),
366}
367
368/// struct for typed errors of method [`nodes_ceph_log`]
369#[derive(Debug, Clone, Serialize, Deserialize)]
370#[serde(untagged)]
371pub enum NodesCephLogError {
372    Status400(models::PveError),
373    Status401(models::PveError),
374    Status403(models::PveError),
375    Status404(models::PveError),
376    Status500(models::PveError),
377    Status501(models::PveError),
378    Status503(models::PveError),
379    UnknownValue(serde_json::Value),
380}
381
382/// struct for typed errors of method [`nodes_ceph_lspools`]
383#[derive(Debug, Clone, Serialize, Deserialize)]
384#[serde(untagged)]
385pub enum NodesCephLspoolsError {
386    Status400(models::PveError),
387    Status401(models::PveError),
388    Status403(models::PveError),
389    Status404(models::PveError),
390    Status500(models::PveError),
391    Status501(models::PveError),
392    Status503(models::PveError),
393    UnknownValue(serde_json::Value),
394}
395
396/// struct for typed errors of method [`nodes_ceph_osddetails`]
397#[derive(Debug, Clone, Serialize, Deserialize)]
398#[serde(untagged)]
399pub enum NodesCephOsddetailsError {
400    Status400(models::PveError),
401    Status401(models::PveError),
402    Status403(models::PveError),
403    Status404(models::PveError),
404    Status500(models::PveError),
405    Status501(models::PveError),
406    Status503(models::PveError),
407    UnknownValue(serde_json::Value),
408}
409
410/// struct for typed errors of method [`nodes_ceph_osdindex`]
411#[derive(Debug, Clone, Serialize, Deserialize)]
412#[serde(untagged)]
413pub enum NodesCephOsdindexError {
414    Status400(models::PveError),
415    Status401(models::PveError),
416    Status403(models::PveError),
417    Status404(models::PveError),
418    Status500(models::PveError),
419    Status501(models::PveError),
420    Status503(models::PveError),
421    UnknownValue(serde_json::Value),
422}
423
424/// struct for typed errors of method [`nodes_ceph_osdvolume`]
425#[derive(Debug, Clone, Serialize, Deserialize)]
426#[serde(untagged)]
427pub enum NodesCephOsdvolumeError {
428    Status400(models::PveError),
429    Status401(models::PveError),
430    Status403(models::PveError),
431    Status404(models::PveError),
432    Status500(models::PveError),
433    Status501(models::PveError),
434    Status503(models::PveError),
435    UnknownValue(serde_json::Value),
436}
437
438/// struct for typed errors of method [`nodes_ceph_out`]
439#[derive(Debug, Clone, Serialize, Deserialize)]
440#[serde(untagged)]
441pub enum NodesCephOutError {
442    Status400(models::PveError),
443    Status401(models::PveError),
444    Status403(models::PveError),
445    Status404(models::PveError),
446    Status500(models::PveError),
447    Status501(models::PveError),
448    Status503(models::PveError),
449    UnknownValue(serde_json::Value),
450}
451
452/// struct for typed errors of method [`nodes_ceph_poolindex`]
453#[derive(Debug, Clone, Serialize, Deserialize)]
454#[serde(untagged)]
455pub enum NodesCephPoolindexError {
456    Status400(models::PveError),
457    Status401(models::PveError),
458    Status403(models::PveError),
459    Status404(models::PveError),
460    Status500(models::PveError),
461    Status501(models::PveError),
462    Status503(models::PveError),
463    UnknownValue(serde_json::Value),
464}
465
466/// struct for typed errors of method [`nodes_ceph_raw`]
467#[derive(Debug, Clone, Serialize, Deserialize)]
468#[serde(untagged)]
469pub enum NodesCephRawError {
470    Status400(models::PveError),
471    Status401(models::PveError),
472    Status403(models::PveError),
473    Status404(models::PveError),
474    Status500(models::PveError),
475    Status501(models::PveError),
476    Status503(models::PveError),
477    UnknownValue(serde_json::Value),
478}
479
480/// struct for typed errors of method [`nodes_ceph_restart`]
481#[derive(Debug, Clone, Serialize, Deserialize)]
482#[serde(untagged)]
483pub enum NodesCephRestartError {
484    Status400(models::PveError),
485    Status401(models::PveError),
486    Status403(models::PveError),
487    Status404(models::PveError),
488    Status500(models::PveError),
489    Status501(models::PveError),
490    Status503(models::PveError),
491    UnknownValue(serde_json::Value),
492}
493
494/// struct for typed errors of method [`nodes_ceph_rules`]
495#[derive(Debug, Clone, Serialize, Deserialize)]
496#[serde(untagged)]
497pub enum NodesCephRulesError {
498    Status400(models::PveError),
499    Status401(models::PveError),
500    Status403(models::PveError),
501    Status404(models::PveError),
502    Status500(models::PveError),
503    Status501(models::PveError),
504    Status503(models::PveError),
505    UnknownValue(serde_json::Value),
506}
507
508/// struct for typed errors of method [`nodes_ceph_scrub`]
509#[derive(Debug, Clone, Serialize, Deserialize)]
510#[serde(untagged)]
511pub enum NodesCephScrubError {
512    Status400(models::PveError),
513    Status401(models::PveError),
514    Status403(models::PveError),
515    Status404(models::PveError),
516    Status500(models::PveError),
517    Status501(models::PveError),
518    Status503(models::PveError),
519    UnknownValue(serde_json::Value),
520}
521
522/// struct for typed errors of method [`nodes_ceph_setpool`]
523#[derive(Debug, Clone, Serialize, Deserialize)]
524#[serde(untagged)]
525pub enum NodesCephSetpoolError {
526    Status400(models::PveError),
527    Status401(models::PveError),
528    Status403(models::PveError),
529    Status404(models::PveError),
530    Status500(models::PveError),
531    Status501(models::PveError),
532    Status503(models::PveError),
533    UnknownValue(serde_json::Value),
534}
535
536/// struct for typed errors of method [`nodes_ceph_start`]
537#[derive(Debug, Clone, Serialize, Deserialize)]
538#[serde(untagged)]
539pub enum NodesCephStartError {
540    Status400(models::PveError),
541    Status401(models::PveError),
542    Status403(models::PveError),
543    Status404(models::PveError),
544    Status500(models::PveError),
545    Status501(models::PveError),
546    Status503(models::PveError),
547    UnknownValue(serde_json::Value),
548}
549
550/// struct for typed errors of method [`nodes_ceph_status`]
551#[derive(Debug, Clone, Serialize, Deserialize)]
552#[serde(untagged)]
553pub enum NodesCephStatusError {
554    Status400(models::PveError),
555    Status401(models::PveError),
556    Status403(models::PveError),
557    Status404(models::PveError),
558    Status500(models::PveError),
559    Status501(models::PveError),
560    Status503(models::PveError),
561    UnknownValue(serde_json::Value),
562}
563
564/// struct for typed errors of method [`nodes_ceph_stop`]
565#[derive(Debug, Clone, Serialize, Deserialize)]
566#[serde(untagged)]
567pub enum NodesCephStopError {
568    Status400(models::PveError),
569    Status401(models::PveError),
570    Status403(models::PveError),
571    Status404(models::PveError),
572    Status500(models::PveError),
573    Status501(models::PveError),
574    Status503(models::PveError),
575    UnknownValue(serde_json::Value),
576}
577
578/// struct for typed errors of method [`nodes_ceph_value`]
579#[derive(Debug, Clone, Serialize, Deserialize)]
580#[serde(untagged)]
581pub enum NodesCephValueError {
582    Status400(models::PveError),
583    Status401(models::PveError),
584    Status403(models::PveError),
585    Status404(models::PveError),
586    Status500(models::PveError),
587    Status501(models::PveError),
588    Status503(models::PveError),
589    UnknownValue(serde_json::Value),
590}
591
592
593/// Heuristical check if it is safe to perform an action.
594pub async fn nodes_ceph_cmd_safety(configuration: &configuration::Configuration, action: models::PveNodesCephActionEnum, id: &str, node: &str, service: models::PveNodesCephServiceEnum) -> Result<models::NodesCephCmdSafetyResponse, Error<NodesCephCmdSafetyError>> {
595    // add a prefix to parameters to efficiently prevent name collisions
596    let p_query_action = action;
597    let p_query_id = id;
598    let p_path_node = node;
599    let p_query_service = service;
600
601    let uri_str = format!("{}/nodes/{node}/ceph/cmd-safety", configuration.base_path, node=crate::apis::urlencode(p_path_node));
602    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
603
604    req_builder = req_builder.query(&[("action", &p_query_action.to_string())]);
605    req_builder = req_builder.query(&[("id", &p_query_id.to_string())]);
606    req_builder = req_builder.query(&[("service", &p_query_service.to_string())]);
607    if let Some(ref user_agent) = configuration.user_agent {
608        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
609    }
610    if let Some(ref apikey) = configuration.api_key {
611        let key = apikey.key.clone();
612        let value = match apikey.prefix {
613            Some(ref prefix) => format!("{} {}", prefix, key),
614            None => key,
615        };
616        req_builder = req_builder.header("Authorization", value);
617    };
618    if let Some(ref apikey) = configuration.api_key {
619        let key = apikey.key.clone();
620        let value = match apikey.prefix {
621            Some(ref prefix) => format!("{} {}", prefix, key),
622            None => key,
623        };
624        req_builder = req_builder.header("CSRFPreventionToken", value);
625    };
626
627    let req = req_builder.build()?;
628    let resp = configuration.client.execute(req).await?;
629
630    let status = resp.status();
631    let content_type = resp
632        .headers()
633        .get("content-type")
634        .and_then(|v| v.to_str().ok())
635        .unwrap_or("application/octet-stream");
636    let content_type = super::ContentType::from(content_type);
637
638    if !status.is_client_error() && !status.is_server_error() {
639        let content = resp.text().await?;
640        match content_type {
641            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
642            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephCmdSafetyResponse`"))),
643            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephCmdSafetyResponse`")))),
644        }
645    } else {
646        let content = resp.text().await?;
647        let entity: Option<NodesCephCmdSafetyError> = serde_json::from_str(&content).ok();
648        Err(Error::ResponseError(ResponseContent { status, content, entity }))
649    }
650}
651
652/// Create a Ceph filesystem
653pub async fn nodes_ceph_createfs(configuration: &configuration::Configuration, name: &str, node: &str, nodes_ceph_createfs_request: Option<models::NodesCephCreatefsRequest>) -> Result<models::NodesCephCreatefsResponse, Error<NodesCephCreatefsError>> {
654    // add a prefix to parameters to efficiently prevent name collisions
655    let p_path_name = name;
656    let p_path_node = node;
657    let p_body_nodes_ceph_createfs_request = nodes_ceph_createfs_request;
658
659    let uri_str = format!("{}/nodes/{node}/ceph/fs/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name), node=crate::apis::urlencode(p_path_node));
660    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
661
662    if let Some(ref user_agent) = configuration.user_agent {
663        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
664    }
665    if let Some(ref apikey) = configuration.api_key {
666        let key = apikey.key.clone();
667        let value = match apikey.prefix {
668            Some(ref prefix) => format!("{} {}", prefix, key),
669            None => key,
670        };
671        req_builder = req_builder.header("Authorization", value);
672    };
673    if let Some(ref apikey) = configuration.api_key {
674        let key = apikey.key.clone();
675        let value = match apikey.prefix {
676            Some(ref prefix) => format!("{} {}", prefix, key),
677            None => key,
678        };
679        req_builder = req_builder.header("CSRFPreventionToken", value);
680    };
681    req_builder = req_builder.json(&p_body_nodes_ceph_createfs_request);
682
683    let req = req_builder.build()?;
684    let resp = configuration.client.execute(req).await?;
685
686    let status = resp.status();
687    let content_type = resp
688        .headers()
689        .get("content-type")
690        .and_then(|v| v.to_str().ok())
691        .unwrap_or("application/octet-stream");
692    let content_type = super::ContentType::from(content_type);
693
694    if !status.is_client_error() && !status.is_server_error() {
695        let content = resp.text().await?;
696        match content_type {
697            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
698            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephCreatefsResponse`"))),
699            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephCreatefsResponse`")))),
700        }
701    } else {
702        let content = resp.text().await?;
703        let entity: Option<NodesCephCreatefsError> = serde_json::from_str(&content).ok();
704        Err(Error::ResponseError(ResponseContent { status, content, entity }))
705    }
706}
707
708/// Create Ceph Metadata Server (MDS)
709pub async fn nodes_ceph_createmds(configuration: &configuration::Configuration, name: &str, node: &str, nodes_ceph_createmds_request: Option<models::NodesCephCreatemdsRequest>) -> Result<models::NodesCephCreatemdsResponse, Error<NodesCephCreatemdsError>> {
710    // add a prefix to parameters to efficiently prevent name collisions
711    let p_path_name = name;
712    let p_path_node = node;
713    let p_body_nodes_ceph_createmds_request = nodes_ceph_createmds_request;
714
715    let uri_str = format!("{}/nodes/{node}/ceph/mds/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name), node=crate::apis::urlencode(p_path_node));
716    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
717
718    if let Some(ref user_agent) = configuration.user_agent {
719        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
720    }
721    if let Some(ref apikey) = configuration.api_key {
722        let key = apikey.key.clone();
723        let value = match apikey.prefix {
724            Some(ref prefix) => format!("{} {}", prefix, key),
725            None => key,
726        };
727        req_builder = req_builder.header("Authorization", value);
728    };
729    if let Some(ref apikey) = configuration.api_key {
730        let key = apikey.key.clone();
731        let value = match apikey.prefix {
732            Some(ref prefix) => format!("{} {}", prefix, key),
733            None => key,
734        };
735        req_builder = req_builder.header("CSRFPreventionToken", value);
736    };
737    req_builder = req_builder.json(&p_body_nodes_ceph_createmds_request);
738
739    let req = req_builder.build()?;
740    let resp = configuration.client.execute(req).await?;
741
742    let status = resp.status();
743    let content_type = resp
744        .headers()
745        .get("content-type")
746        .and_then(|v| v.to_str().ok())
747        .unwrap_or("application/octet-stream");
748    let content_type = super::ContentType::from(content_type);
749
750    if !status.is_client_error() && !status.is_server_error() {
751        let content = resp.text().await?;
752        match content_type {
753            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
754            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephCreatemdsResponse`"))),
755            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephCreatemdsResponse`")))),
756        }
757    } else {
758        let content = resp.text().await?;
759        let entity: Option<NodesCephCreatemdsError> = serde_json::from_str(&content).ok();
760        Err(Error::ResponseError(ResponseContent { status, content, entity }))
761    }
762}
763
764/// Create Ceph Manager
765pub async fn nodes_ceph_createmgr(configuration: &configuration::Configuration, id: &str, node: &str) -> Result<models::NodesCephCreatemgrResponse, Error<NodesCephCreatemgrError>> {
766    // add a prefix to parameters to efficiently prevent name collisions
767    let p_path_id = id;
768    let p_path_node = node;
769
770    let uri_str = format!("{}/nodes/{node}/ceph/mgr/{id}", configuration.base_path, id=crate::apis::urlencode(p_path_id), node=crate::apis::urlencode(p_path_node));
771    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
772
773    if let Some(ref user_agent) = configuration.user_agent {
774        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
775    }
776    if let Some(ref apikey) = configuration.api_key {
777        let key = apikey.key.clone();
778        let value = match apikey.prefix {
779            Some(ref prefix) => format!("{} {}", prefix, key),
780            None => key,
781        };
782        req_builder = req_builder.header("Authorization", value);
783    };
784    if let Some(ref apikey) = configuration.api_key {
785        let key = apikey.key.clone();
786        let value = match apikey.prefix {
787            Some(ref prefix) => format!("{} {}", prefix, key),
788            None => key,
789        };
790        req_builder = req_builder.header("CSRFPreventionToken", value);
791    };
792
793    let req = req_builder.build()?;
794    let resp = configuration.client.execute(req).await?;
795
796    let status = resp.status();
797    let content_type = resp
798        .headers()
799        .get("content-type")
800        .and_then(|v| v.to_str().ok())
801        .unwrap_or("application/octet-stream");
802    let content_type = super::ContentType::from(content_type);
803
804    if !status.is_client_error() && !status.is_server_error() {
805        let content = resp.text().await?;
806        match content_type {
807            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
808            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephCreatemgrResponse`"))),
809            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephCreatemgrResponse`")))),
810        }
811    } else {
812        let content = resp.text().await?;
813        let entity: Option<NodesCephCreatemgrError> = serde_json::from_str(&content).ok();
814        Err(Error::ResponseError(ResponseContent { status, content, entity }))
815    }
816}
817
818/// Create a Ceph Monitor. Also auto-creates a Manager for the first monitor.
819pub async fn nodes_ceph_createmon(configuration: &configuration::Configuration, monid: &str, node: &str, nodes_ceph_createmon_request: Option<models::NodesCephCreatemonRequest>) -> Result<models::NodesCephCreatemonResponse, Error<NodesCephCreatemonError>> {
820    // add a prefix to parameters to efficiently prevent name collisions
821    let p_path_monid = monid;
822    let p_path_node = node;
823    let p_body_nodes_ceph_createmon_request = nodes_ceph_createmon_request;
824
825    let uri_str = format!("{}/nodes/{node}/ceph/mon/{monid}", configuration.base_path, monid=crate::apis::urlencode(p_path_monid), node=crate::apis::urlencode(p_path_node));
826    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
827
828    if let Some(ref user_agent) = configuration.user_agent {
829        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
830    }
831    if let Some(ref apikey) = configuration.api_key {
832        let key = apikey.key.clone();
833        let value = match apikey.prefix {
834            Some(ref prefix) => format!("{} {}", prefix, key),
835            None => key,
836        };
837        req_builder = req_builder.header("Authorization", value);
838    };
839    if let Some(ref apikey) = configuration.api_key {
840        let key = apikey.key.clone();
841        let value = match apikey.prefix {
842            Some(ref prefix) => format!("{} {}", prefix, key),
843            None => key,
844        };
845        req_builder = req_builder.header("CSRFPreventionToken", value);
846    };
847    req_builder = req_builder.json(&p_body_nodes_ceph_createmon_request);
848
849    let req = req_builder.build()?;
850    let resp = configuration.client.execute(req).await?;
851
852    let status = resp.status();
853    let content_type = resp
854        .headers()
855        .get("content-type")
856        .and_then(|v| v.to_str().ok())
857        .unwrap_or("application/octet-stream");
858    let content_type = super::ContentType::from(content_type);
859
860    if !status.is_client_error() && !status.is_server_error() {
861        let content = resp.text().await?;
862        match content_type {
863            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
864            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephCreatemonResponse`"))),
865            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephCreatemonResponse`")))),
866        }
867    } else {
868        let content = resp.text().await?;
869        let entity: Option<NodesCephCreatemonError> = serde_json::from_str(&content).ok();
870        Err(Error::ResponseError(ResponseContent { status, content, entity }))
871    }
872}
873
874/// Create OSD
875pub async fn nodes_ceph_createosd(configuration: &configuration::Configuration, node: &str, nodes_ceph_createosd_request: models::NodesCephCreateosdRequest) -> Result<models::NodesCephCreateosdResponse, Error<NodesCephCreateosdError>> {
876    // add a prefix to parameters to efficiently prevent name collisions
877    let p_path_node = node;
878    let p_body_nodes_ceph_createosd_request = nodes_ceph_createosd_request;
879
880    let uri_str = format!("{}/nodes/{node}/ceph/osd", configuration.base_path, node=crate::apis::urlencode(p_path_node));
881    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
882
883    if let Some(ref user_agent) = configuration.user_agent {
884        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
885    }
886    if let Some(ref apikey) = configuration.api_key {
887        let key = apikey.key.clone();
888        let value = match apikey.prefix {
889            Some(ref prefix) => format!("{} {}", prefix, key),
890            None => key,
891        };
892        req_builder = req_builder.header("Authorization", value);
893    };
894    if let Some(ref apikey) = configuration.api_key {
895        let key = apikey.key.clone();
896        let value = match apikey.prefix {
897            Some(ref prefix) => format!("{} {}", prefix, key),
898            None => key,
899        };
900        req_builder = req_builder.header("CSRFPreventionToken", value);
901    };
902    req_builder = req_builder.json(&p_body_nodes_ceph_createosd_request);
903
904    let req = req_builder.build()?;
905    let resp = configuration.client.execute(req).await?;
906
907    let status = resp.status();
908    let content_type = resp
909        .headers()
910        .get("content-type")
911        .and_then(|v| v.to_str().ok())
912        .unwrap_or("application/octet-stream");
913    let content_type = super::ContentType::from(content_type);
914
915    if !status.is_client_error() && !status.is_server_error() {
916        let content = resp.text().await?;
917        match content_type {
918            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
919            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephCreateosdResponse`"))),
920            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephCreateosdResponse`")))),
921        }
922    } else {
923        let content = resp.text().await?;
924        let entity: Option<NodesCephCreateosdError> = serde_json::from_str(&content).ok();
925        Err(Error::ResponseError(ResponseContent { status, content, entity }))
926    }
927}
928
929/// Create Ceph pool
930pub async fn nodes_ceph_createpool(configuration: &configuration::Configuration, node: &str, nodes_ceph_createpool_request: models::NodesCephCreatepoolRequest) -> Result<models::NodesCephCreatepoolResponse, Error<NodesCephCreatepoolError>> {
931    // add a prefix to parameters to efficiently prevent name collisions
932    let p_path_node = node;
933    let p_body_nodes_ceph_createpool_request = nodes_ceph_createpool_request;
934
935    let uri_str = format!("{}/nodes/{node}/ceph/pool", configuration.base_path, node=crate::apis::urlencode(p_path_node));
936    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
937
938    if let Some(ref user_agent) = configuration.user_agent {
939        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
940    }
941    if let Some(ref apikey) = configuration.api_key {
942        let key = apikey.key.clone();
943        let value = match apikey.prefix {
944            Some(ref prefix) => format!("{} {}", prefix, key),
945            None => key,
946        };
947        req_builder = req_builder.header("Authorization", value);
948    };
949    if let Some(ref apikey) = configuration.api_key {
950        let key = apikey.key.clone();
951        let value = match apikey.prefix {
952            Some(ref prefix) => format!("{} {}", prefix, key),
953            None => key,
954        };
955        req_builder = req_builder.header("CSRFPreventionToken", value);
956    };
957    req_builder = req_builder.json(&p_body_nodes_ceph_createpool_request);
958
959    let req = req_builder.build()?;
960    let resp = configuration.client.execute(req).await?;
961
962    let status = resp.status();
963    let content_type = resp
964        .headers()
965        .get("content-type")
966        .and_then(|v| v.to_str().ok())
967        .unwrap_or("application/octet-stream");
968    let content_type = super::ContentType::from(content_type);
969
970    if !status.is_client_error() && !status.is_server_error() {
971        let content = resp.text().await?;
972        match content_type {
973            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
974            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephCreatepoolResponse`"))),
975            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephCreatepoolResponse`")))),
976        }
977    } else {
978        let content = resp.text().await?;
979        let entity: Option<NodesCephCreatepoolError> = serde_json::from_str(&content).ok();
980        Err(Error::ResponseError(ResponseContent { status, content, entity }))
981    }
982}
983
984/// Get OSD crush map
985pub async fn nodes_ceph_crush(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesCephCrushResponse, Error<NodesCephCrushError>> {
986    // add a prefix to parameters to efficiently prevent name collisions
987    let p_path_node = node;
988
989    let uri_str = format!("{}/nodes/{node}/ceph/crush", configuration.base_path, node=crate::apis::urlencode(p_path_node));
990    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
991
992    if let Some(ref user_agent) = configuration.user_agent {
993        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
994    }
995    if let Some(ref apikey) = configuration.api_key {
996        let key = apikey.key.clone();
997        let value = match apikey.prefix {
998            Some(ref prefix) => format!("{} {}", prefix, key),
999            None => key,
1000        };
1001        req_builder = req_builder.header("Authorization", value);
1002    };
1003    if let Some(ref apikey) = configuration.api_key {
1004        let key = apikey.key.clone();
1005        let value = match apikey.prefix {
1006            Some(ref prefix) => format!("{} {}", prefix, key),
1007            None => key,
1008        };
1009        req_builder = req_builder.header("CSRFPreventionToken", value);
1010    };
1011
1012    let req = req_builder.build()?;
1013    let resp = configuration.client.execute(req).await?;
1014
1015    let status = resp.status();
1016    let content_type = resp
1017        .headers()
1018        .get("content-type")
1019        .and_then(|v| v.to_str().ok())
1020        .unwrap_or("application/octet-stream");
1021    let content_type = super::ContentType::from(content_type);
1022
1023    if !status.is_client_error() && !status.is_server_error() {
1024        let content = resp.text().await?;
1025        match content_type {
1026            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1027            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephCrushResponse`"))),
1028            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephCrushResponse`")))),
1029        }
1030    } else {
1031        let content = resp.text().await?;
1032        let entity: Option<NodesCephCrushError> = serde_json::from_str(&content).ok();
1033        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1034    }
1035}
1036
1037/// Get the Ceph configuration database.
1038pub async fn nodes_ceph_db(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesCephDbResponse, Error<NodesCephDbError>> {
1039    // add a prefix to parameters to efficiently prevent name collisions
1040    let p_path_node = node;
1041
1042    let uri_str = format!("{}/nodes/{node}/ceph/cfg/db", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1043    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1044
1045    if let Some(ref user_agent) = configuration.user_agent {
1046        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1047    }
1048    if let Some(ref apikey) = configuration.api_key {
1049        let key = apikey.key.clone();
1050        let value = match apikey.prefix {
1051            Some(ref prefix) => format!("{} {}", prefix, key),
1052            None => key,
1053        };
1054        req_builder = req_builder.header("Authorization", value);
1055    };
1056    if let Some(ref apikey) = configuration.api_key {
1057        let key = apikey.key.clone();
1058        let value = match apikey.prefix {
1059            Some(ref prefix) => format!("{} {}", prefix, key),
1060            None => key,
1061        };
1062        req_builder = req_builder.header("CSRFPreventionToken", value);
1063    };
1064
1065    let req = req_builder.build()?;
1066    let resp = configuration.client.execute(req).await?;
1067
1068    let status = resp.status();
1069    let content_type = resp
1070        .headers()
1071        .get("content-type")
1072        .and_then(|v| v.to_str().ok())
1073        .unwrap_or("application/octet-stream");
1074    let content_type = super::ContentType::from(content_type);
1075
1076    if !status.is_client_error() && !status.is_server_error() {
1077        let content = resp.text().await?;
1078        match content_type {
1079            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1080            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephDbResponse`"))),
1081            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephDbResponse`")))),
1082        }
1083    } else {
1084        let content = resp.text().await?;
1085        let entity: Option<NodesCephDbError> = serde_json::from_str(&content).ok();
1086        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1087    }
1088}
1089
1090/// Destroy a Ceph filesystem. Refuses if any PVE storage entry of type 'cephfs' still references the filesystem and is not disabled. Optionally also removes the storage entries and/or the underlying metadata and data pools.
1091pub async fn nodes_ceph_destroyfs(configuration: &configuration::Configuration, name: &str, node: &str, remove_pools: Option<&str>, remove_storages: Option<&str>) -> Result<models::NodesCephDestroyfsResponse, Error<NodesCephDestroyfsError>> {
1092    // add a prefix to parameters to efficiently prevent name collisions
1093    let p_path_name = name;
1094    let p_path_node = node;
1095    let p_query_remove_pools = remove_pools;
1096    let p_query_remove_storages = remove_storages;
1097
1098    let uri_str = format!("{}/nodes/{node}/ceph/fs/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name), node=crate::apis::urlencode(p_path_node));
1099    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
1100
1101    if let Some(ref param_value) = p_query_remove_pools {
1102        req_builder = req_builder.query(&[("remove-pools", &param_value.to_string())]);
1103    }
1104    if let Some(ref param_value) = p_query_remove_storages {
1105        req_builder = req_builder.query(&[("remove-storages", &param_value.to_string())]);
1106    }
1107    if let Some(ref user_agent) = configuration.user_agent {
1108        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1109    }
1110    if let Some(ref apikey) = configuration.api_key {
1111        let key = apikey.key.clone();
1112        let value = match apikey.prefix {
1113            Some(ref prefix) => format!("{} {}", prefix, key),
1114            None => key,
1115        };
1116        req_builder = req_builder.header("Authorization", value);
1117    };
1118    if let Some(ref apikey) = configuration.api_key {
1119        let key = apikey.key.clone();
1120        let value = match apikey.prefix {
1121            Some(ref prefix) => format!("{} {}", prefix, key),
1122            None => key,
1123        };
1124        req_builder = req_builder.header("CSRFPreventionToken", value);
1125    };
1126
1127    let req = req_builder.build()?;
1128    let resp = configuration.client.execute(req).await?;
1129
1130    let status = resp.status();
1131    let content_type = resp
1132        .headers()
1133        .get("content-type")
1134        .and_then(|v| v.to_str().ok())
1135        .unwrap_or("application/octet-stream");
1136    let content_type = super::ContentType::from(content_type);
1137
1138    if !status.is_client_error() && !status.is_server_error() {
1139        let content = resp.text().await?;
1140        match content_type {
1141            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1142            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephDestroyfsResponse`"))),
1143            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephDestroyfsResponse`")))),
1144        }
1145    } else {
1146        let content = resp.text().await?;
1147        let entity: Option<NodesCephDestroyfsError> = serde_json::from_str(&content).ok();
1148        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1149    }
1150}
1151
1152/// Destroy Ceph Metadata Server
1153pub async fn nodes_ceph_destroymds(configuration: &configuration::Configuration, name: &str, node: &str) -> Result<models::NodesCephDestroymdsResponse, Error<NodesCephDestroymdsError>> {
1154    // add a prefix to parameters to efficiently prevent name collisions
1155    let p_path_name = name;
1156    let p_path_node = node;
1157
1158    let uri_str = format!("{}/nodes/{node}/ceph/mds/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name), node=crate::apis::urlencode(p_path_node));
1159    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
1160
1161    if let Some(ref user_agent) = configuration.user_agent {
1162        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1163    }
1164    if let Some(ref apikey) = configuration.api_key {
1165        let key = apikey.key.clone();
1166        let value = match apikey.prefix {
1167            Some(ref prefix) => format!("{} {}", prefix, key),
1168            None => key,
1169        };
1170        req_builder = req_builder.header("Authorization", value);
1171    };
1172    if let Some(ref apikey) = configuration.api_key {
1173        let key = apikey.key.clone();
1174        let value = match apikey.prefix {
1175            Some(ref prefix) => format!("{} {}", prefix, key),
1176            None => key,
1177        };
1178        req_builder = req_builder.header("CSRFPreventionToken", value);
1179    };
1180
1181    let req = req_builder.build()?;
1182    let resp = configuration.client.execute(req).await?;
1183
1184    let status = resp.status();
1185    let content_type = resp
1186        .headers()
1187        .get("content-type")
1188        .and_then(|v| v.to_str().ok())
1189        .unwrap_or("application/octet-stream");
1190    let content_type = super::ContentType::from(content_type);
1191
1192    if !status.is_client_error() && !status.is_server_error() {
1193        let content = resp.text().await?;
1194        match content_type {
1195            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1196            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephDestroymdsResponse`"))),
1197            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephDestroymdsResponse`")))),
1198        }
1199    } else {
1200        let content = resp.text().await?;
1201        let entity: Option<NodesCephDestroymdsError> = serde_json::from_str(&content).ok();
1202        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1203    }
1204}
1205
1206/// Destroy Ceph Manager.
1207pub async fn nodes_ceph_destroymgr(configuration: &configuration::Configuration, id: &str, node: &str) -> Result<models::NodesCephDestroymgrResponse, Error<NodesCephDestroymgrError>> {
1208    // add a prefix to parameters to efficiently prevent name collisions
1209    let p_path_id = id;
1210    let p_path_node = node;
1211
1212    let uri_str = format!("{}/nodes/{node}/ceph/mgr/{id}", configuration.base_path, id=crate::apis::urlencode(p_path_id), node=crate::apis::urlencode(p_path_node));
1213    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
1214
1215    if let Some(ref user_agent) = configuration.user_agent {
1216        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1217    }
1218    if let Some(ref apikey) = configuration.api_key {
1219        let key = apikey.key.clone();
1220        let value = match apikey.prefix {
1221            Some(ref prefix) => format!("{} {}", prefix, key),
1222            None => key,
1223        };
1224        req_builder = req_builder.header("Authorization", value);
1225    };
1226    if let Some(ref apikey) = configuration.api_key {
1227        let key = apikey.key.clone();
1228        let value = match apikey.prefix {
1229            Some(ref prefix) => format!("{} {}", prefix, key),
1230            None => key,
1231        };
1232        req_builder = req_builder.header("CSRFPreventionToken", value);
1233    };
1234
1235    let req = req_builder.build()?;
1236    let resp = configuration.client.execute(req).await?;
1237
1238    let status = resp.status();
1239    let content_type = resp
1240        .headers()
1241        .get("content-type")
1242        .and_then(|v| v.to_str().ok())
1243        .unwrap_or("application/octet-stream");
1244    let content_type = super::ContentType::from(content_type);
1245
1246    if !status.is_client_error() && !status.is_server_error() {
1247        let content = resp.text().await?;
1248        match content_type {
1249            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1250            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephDestroymgrResponse`"))),
1251            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephDestroymgrResponse`")))),
1252        }
1253    } else {
1254        let content = resp.text().await?;
1255        let entity: Option<NodesCephDestroymgrError> = serde_json::from_str(&content).ok();
1256        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1257    }
1258}
1259
1260/// Destroy a Ceph Monitor. Refuses to remove the last monitor of the cluster. Does not destroy any Manager on the same node; use /nodes/{node}/ceph/mgr/{id} for that.
1261pub async fn nodes_ceph_destroymon(configuration: &configuration::Configuration, monid: &str, node: &str) -> Result<models::NodesCephDestroymonResponse, Error<NodesCephDestroymonError>> {
1262    // add a prefix to parameters to efficiently prevent name collisions
1263    let p_path_monid = monid;
1264    let p_path_node = node;
1265
1266    let uri_str = format!("{}/nodes/{node}/ceph/mon/{monid}", configuration.base_path, monid=crate::apis::urlencode(p_path_monid), node=crate::apis::urlencode(p_path_node));
1267    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
1268
1269    if let Some(ref user_agent) = configuration.user_agent {
1270        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1271    }
1272    if let Some(ref apikey) = configuration.api_key {
1273        let key = apikey.key.clone();
1274        let value = match apikey.prefix {
1275            Some(ref prefix) => format!("{} {}", prefix, key),
1276            None => key,
1277        };
1278        req_builder = req_builder.header("Authorization", value);
1279    };
1280    if let Some(ref apikey) = configuration.api_key {
1281        let key = apikey.key.clone();
1282        let value = match apikey.prefix {
1283            Some(ref prefix) => format!("{} {}", prefix, key),
1284            None => key,
1285        };
1286        req_builder = req_builder.header("CSRFPreventionToken", value);
1287    };
1288
1289    let req = req_builder.build()?;
1290    let resp = configuration.client.execute(req).await?;
1291
1292    let status = resp.status();
1293    let content_type = resp
1294        .headers()
1295        .get("content-type")
1296        .and_then(|v| v.to_str().ok())
1297        .unwrap_or("application/octet-stream");
1298    let content_type = super::ContentType::from(content_type);
1299
1300    if !status.is_client_error() && !status.is_server_error() {
1301        let content = resp.text().await?;
1302        match content_type {
1303            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1304            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephDestroymonResponse`"))),
1305            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephDestroymonResponse`")))),
1306        }
1307    } else {
1308        let content = resp.text().await?;
1309        let entity: Option<NodesCephDestroymonError> = serde_json::from_str(&content).ok();
1310        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1311    }
1312}
1313
1314/// Destroy OSD
1315pub async fn nodes_ceph_destroyosd(configuration: &configuration::Configuration, node: &str, osdid: i64, cleanup: Option<&str>) -> Result<models::NodesCephDestroyosdResponse, Error<NodesCephDestroyosdError>> {
1316    // add a prefix to parameters to efficiently prevent name collisions
1317    let p_path_node = node;
1318    let p_path_osdid = osdid;
1319    let p_query_cleanup = cleanup;
1320
1321    let uri_str = format!("{}/nodes/{node}/ceph/osd/{osdid}", configuration.base_path, node=crate::apis::urlencode(p_path_node), osdid=p_path_osdid);
1322    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
1323
1324    if let Some(ref param_value) = p_query_cleanup {
1325        req_builder = req_builder.query(&[("cleanup", &param_value.to_string())]);
1326    }
1327    if let Some(ref user_agent) = configuration.user_agent {
1328        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1329    }
1330    if let Some(ref apikey) = configuration.api_key {
1331        let key = apikey.key.clone();
1332        let value = match apikey.prefix {
1333            Some(ref prefix) => format!("{} {}", prefix, key),
1334            None => key,
1335        };
1336        req_builder = req_builder.header("Authorization", value);
1337    };
1338    if let Some(ref apikey) = configuration.api_key {
1339        let key = apikey.key.clone();
1340        let value = match apikey.prefix {
1341            Some(ref prefix) => format!("{} {}", prefix, key),
1342            None => key,
1343        };
1344        req_builder = req_builder.header("CSRFPreventionToken", value);
1345    };
1346
1347    let req = req_builder.build()?;
1348    let resp = configuration.client.execute(req).await?;
1349
1350    let status = resp.status();
1351    let content_type = resp
1352        .headers()
1353        .get("content-type")
1354        .and_then(|v| v.to_str().ok())
1355        .unwrap_or("application/octet-stream");
1356    let content_type = super::ContentType::from(content_type);
1357
1358    if !status.is_client_error() && !status.is_server_error() {
1359        let content = resp.text().await?;
1360        match content_type {
1361            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1362            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephDestroyosdResponse`"))),
1363            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephDestroyosdResponse`")))),
1364        }
1365    } else {
1366        let content = resp.text().await?;
1367        let entity: Option<NodesCephDestroyosdError> = serde_json::from_str(&content).ok();
1368        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1369    }
1370}
1371
1372/// Destroy pool
1373pub async fn nodes_ceph_destroypool(configuration: &configuration::Configuration, name: &str, node: &str, force: Option<&str>, remove_ecprofile: Option<&str>, remove_storages: Option<&str>) -> Result<models::NodesCephDestroypoolResponse, Error<NodesCephDestroypoolError>> {
1374    // add a prefix to parameters to efficiently prevent name collisions
1375    let p_path_name = name;
1376    let p_path_node = node;
1377    let p_query_force = force;
1378    let p_query_remove_ecprofile = remove_ecprofile;
1379    let p_query_remove_storages = remove_storages;
1380
1381    let uri_str = format!("{}/nodes/{node}/ceph/pool/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name), node=crate::apis::urlencode(p_path_node));
1382    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
1383
1384    if let Some(ref param_value) = p_query_force {
1385        req_builder = req_builder.query(&[("force", &param_value.to_string())]);
1386    }
1387    if let Some(ref param_value) = p_query_remove_ecprofile {
1388        req_builder = req_builder.query(&[("remove_ecprofile", &param_value.to_string())]);
1389    }
1390    if let Some(ref param_value) = p_query_remove_storages {
1391        req_builder = req_builder.query(&[("remove_storages", &param_value.to_string())]);
1392    }
1393    if let Some(ref user_agent) = configuration.user_agent {
1394        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1395    }
1396    if let Some(ref apikey) = configuration.api_key {
1397        let key = apikey.key.clone();
1398        let value = match apikey.prefix {
1399            Some(ref prefix) => format!("{} {}", prefix, key),
1400            None => key,
1401        };
1402        req_builder = req_builder.header("Authorization", value);
1403    };
1404    if let Some(ref apikey) = configuration.api_key {
1405        let key = apikey.key.clone();
1406        let value = match apikey.prefix {
1407            Some(ref prefix) => format!("{} {}", prefix, key),
1408            None => key,
1409        };
1410        req_builder = req_builder.header("CSRFPreventionToken", value);
1411    };
1412
1413    let req = req_builder.build()?;
1414    let resp = configuration.client.execute(req).await?;
1415
1416    let status = resp.status();
1417    let content_type = resp
1418        .headers()
1419        .get("content-type")
1420        .and_then(|v| v.to_str().ok())
1421        .unwrap_or("application/octet-stream");
1422    let content_type = super::ContentType::from(content_type);
1423
1424    if !status.is_client_error() && !status.is_server_error() {
1425        let content = resp.text().await?;
1426        match content_type {
1427            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1428            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephDestroypoolResponse`"))),
1429            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephDestroypoolResponse`")))),
1430        }
1431    } else {
1432        let content = resp.text().await?;
1433        let entity: Option<NodesCephDestroypoolError> = serde_json::from_str(&content).ok();
1434        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1435    }
1436}
1437
1438/// Directory index.
1439pub async fn nodes_ceph_get_ceph(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesCephGetCephResponse, Error<NodesCephGetCephError>> {
1440    // add a prefix to parameters to efficiently prevent name collisions
1441    let p_path_node = node;
1442
1443    let uri_str = format!("{}/nodes/{node}/ceph", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1444    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1445
1446    if let Some(ref user_agent) = configuration.user_agent {
1447        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1448    }
1449    if let Some(ref apikey) = configuration.api_key {
1450        let key = apikey.key.clone();
1451        let value = match apikey.prefix {
1452            Some(ref prefix) => format!("{} {}", prefix, key),
1453            None => key,
1454        };
1455        req_builder = req_builder.header("Authorization", value);
1456    };
1457    if let Some(ref apikey) = configuration.api_key {
1458        let key = apikey.key.clone();
1459        let value = match apikey.prefix {
1460            Some(ref prefix) => format!("{} {}", prefix, key),
1461            None => key,
1462        };
1463        req_builder = req_builder.header("CSRFPreventionToken", value);
1464    };
1465
1466    let req = req_builder.build()?;
1467    let resp = configuration.client.execute(req).await?;
1468
1469    let status = resp.status();
1470    let content_type = resp
1471        .headers()
1472        .get("content-type")
1473        .and_then(|v| v.to_str().ok())
1474        .unwrap_or("application/octet-stream");
1475    let content_type = super::ContentType::from(content_type);
1476
1477    if !status.is_client_error() && !status.is_server_error() {
1478        let content = resp.text().await?;
1479        match content_type {
1480            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1481            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephGetCephResponse`"))),
1482            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephGetCephResponse`")))),
1483        }
1484    } else {
1485        let content = resp.text().await?;
1486        let entity: Option<NodesCephGetCephError> = serde_json::from_str(&content).ok();
1487        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1488    }
1489}
1490
1491/// Directory index.
1492pub async fn nodes_ceph_get_cfg(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesCephGetCfgResponse, Error<NodesCephGetCfgError>> {
1493    // add a prefix to parameters to efficiently prevent name collisions
1494    let p_path_node = node;
1495
1496    let uri_str = format!("{}/nodes/{node}/ceph/cfg", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1497    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1498
1499    if let Some(ref user_agent) = configuration.user_agent {
1500        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1501    }
1502    if let Some(ref apikey) = configuration.api_key {
1503        let key = apikey.key.clone();
1504        let value = match apikey.prefix {
1505            Some(ref prefix) => format!("{} {}", prefix, key),
1506            None => key,
1507        };
1508        req_builder = req_builder.header("Authorization", value);
1509    };
1510    if let Some(ref apikey) = configuration.api_key {
1511        let key = apikey.key.clone();
1512        let value = match apikey.prefix {
1513            Some(ref prefix) => format!("{} {}", prefix, key),
1514            None => key,
1515        };
1516        req_builder = req_builder.header("CSRFPreventionToken", value);
1517    };
1518
1519    let req = req_builder.build()?;
1520    let resp = configuration.client.execute(req).await?;
1521
1522    let status = resp.status();
1523    let content_type = resp
1524        .headers()
1525        .get("content-type")
1526        .and_then(|v| v.to_str().ok())
1527        .unwrap_or("application/octet-stream");
1528    let content_type = super::ContentType::from(content_type);
1529
1530    if !status.is_client_error() && !status.is_server_error() {
1531        let content = resp.text().await?;
1532        match content_type {
1533            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1534            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephGetCfgResponse`"))),
1535            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephGetCfgResponse`")))),
1536        }
1537    } else {
1538        let content = resp.text().await?;
1539        let entity: Option<NodesCephGetCfgError> = serde_json::from_str(&content).ok();
1540        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1541    }
1542}
1543
1544/// Directory index.
1545pub async fn nodes_ceph_get_fs(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesCephGetFsResponse, Error<NodesCephGetFsError>> {
1546    // add a prefix to parameters to efficiently prevent name collisions
1547    let p_path_node = node;
1548
1549    let uri_str = format!("{}/nodes/{node}/ceph/fs", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1550    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1551
1552    if let Some(ref user_agent) = configuration.user_agent {
1553        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1554    }
1555    if let Some(ref apikey) = configuration.api_key {
1556        let key = apikey.key.clone();
1557        let value = match apikey.prefix {
1558            Some(ref prefix) => format!("{} {}", prefix, key),
1559            None => key,
1560        };
1561        req_builder = req_builder.header("Authorization", value);
1562    };
1563    if let Some(ref apikey) = configuration.api_key {
1564        let key = apikey.key.clone();
1565        let value = match apikey.prefix {
1566            Some(ref prefix) => format!("{} {}", prefix, key),
1567            None => key,
1568        };
1569        req_builder = req_builder.header("CSRFPreventionToken", value);
1570    };
1571
1572    let req = req_builder.build()?;
1573    let resp = configuration.client.execute(req).await?;
1574
1575    let status = resp.status();
1576    let content_type = resp
1577        .headers()
1578        .get("content-type")
1579        .and_then(|v| v.to_str().ok())
1580        .unwrap_or("application/octet-stream");
1581    let content_type = super::ContentType::from(content_type);
1582
1583    if !status.is_client_error() && !status.is_server_error() {
1584        let content = resp.text().await?;
1585        match content_type {
1586            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1587            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephGetFsResponse`"))),
1588            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephGetFsResponse`")))),
1589        }
1590    } else {
1591        let content = resp.text().await?;
1592        let entity: Option<NodesCephGetFsError> = serde_json::from_str(&content).ok();
1593        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1594    }
1595}
1596
1597/// MDS directory index.
1598pub async fn nodes_ceph_get_mds(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesCephGetMdsResponse, Error<NodesCephGetMdsError>> {
1599    // add a prefix to parameters to efficiently prevent name collisions
1600    let p_path_node = node;
1601
1602    let uri_str = format!("{}/nodes/{node}/ceph/mds", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1603    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1604
1605    if let Some(ref user_agent) = configuration.user_agent {
1606        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1607    }
1608    if let Some(ref apikey) = configuration.api_key {
1609        let key = apikey.key.clone();
1610        let value = match apikey.prefix {
1611            Some(ref prefix) => format!("{} {}", prefix, key),
1612            None => key,
1613        };
1614        req_builder = req_builder.header("Authorization", value);
1615    };
1616    if let Some(ref apikey) = configuration.api_key {
1617        let key = apikey.key.clone();
1618        let value = match apikey.prefix {
1619            Some(ref prefix) => format!("{} {}", prefix, key),
1620            None => key,
1621        };
1622        req_builder = req_builder.header("CSRFPreventionToken", value);
1623    };
1624
1625    let req = req_builder.build()?;
1626    let resp = configuration.client.execute(req).await?;
1627
1628    let status = resp.status();
1629    let content_type = resp
1630        .headers()
1631        .get("content-type")
1632        .and_then(|v| v.to_str().ok())
1633        .unwrap_or("application/octet-stream");
1634    let content_type = super::ContentType::from(content_type);
1635
1636    if !status.is_client_error() && !status.is_server_error() {
1637        let content = resp.text().await?;
1638        match content_type {
1639            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1640            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephGetMdsResponse`"))),
1641            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephGetMdsResponse`")))),
1642        }
1643    } else {
1644        let content = resp.text().await?;
1645        let entity: Option<NodesCephGetMdsError> = serde_json::from_str(&content).ok();
1646        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1647    }
1648}
1649
1650/// MGR directory index.
1651pub async fn nodes_ceph_get_mgr(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesCephGetMgrResponse, Error<NodesCephGetMgrError>> {
1652    // add a prefix to parameters to efficiently prevent name collisions
1653    let p_path_node = node;
1654
1655    let uri_str = format!("{}/nodes/{node}/ceph/mgr", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1656    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1657
1658    if let Some(ref user_agent) = configuration.user_agent {
1659        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1660    }
1661    if let Some(ref apikey) = configuration.api_key {
1662        let key = apikey.key.clone();
1663        let value = match apikey.prefix {
1664            Some(ref prefix) => format!("{} {}", prefix, key),
1665            None => key,
1666        };
1667        req_builder = req_builder.header("Authorization", value);
1668    };
1669    if let Some(ref apikey) = configuration.api_key {
1670        let key = apikey.key.clone();
1671        let value = match apikey.prefix {
1672            Some(ref prefix) => format!("{} {}", prefix, key),
1673            None => key,
1674        };
1675        req_builder = req_builder.header("CSRFPreventionToken", value);
1676    };
1677
1678    let req = req_builder.build()?;
1679    let resp = configuration.client.execute(req).await?;
1680
1681    let status = resp.status();
1682    let content_type = resp
1683        .headers()
1684        .get("content-type")
1685        .and_then(|v| v.to_str().ok())
1686        .unwrap_or("application/octet-stream");
1687    let content_type = super::ContentType::from(content_type);
1688
1689    if !status.is_client_error() && !status.is_server_error() {
1690        let content = resp.text().await?;
1691        match content_type {
1692            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1693            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephGetMgrResponse`"))),
1694            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephGetMgrResponse`")))),
1695        }
1696    } else {
1697        let content = resp.text().await?;
1698        let entity: Option<NodesCephGetMgrError> = serde_json::from_str(&content).ok();
1699        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1700    }
1701}
1702
1703/// Get Ceph osd list/tree.
1704pub async fn nodes_ceph_get_osd(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesCephGetOsdResponse, Error<NodesCephGetOsdError>> {
1705    // add a prefix to parameters to efficiently prevent name collisions
1706    let p_path_node = node;
1707
1708    let uri_str = format!("{}/nodes/{node}/ceph/osd", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1709    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1710
1711    if let Some(ref user_agent) = configuration.user_agent {
1712        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1713    }
1714    if let Some(ref apikey) = configuration.api_key {
1715        let key = apikey.key.clone();
1716        let value = match apikey.prefix {
1717            Some(ref prefix) => format!("{} {}", prefix, key),
1718            None => key,
1719        };
1720        req_builder = req_builder.header("Authorization", value);
1721    };
1722    if let Some(ref apikey) = configuration.api_key {
1723        let key = apikey.key.clone();
1724        let value = match apikey.prefix {
1725            Some(ref prefix) => format!("{} {}", prefix, key),
1726            None => key,
1727        };
1728        req_builder = req_builder.header("CSRFPreventionToken", value);
1729    };
1730
1731    let req = req_builder.build()?;
1732    let resp = configuration.client.execute(req).await?;
1733
1734    let status = resp.status();
1735    let content_type = resp
1736        .headers()
1737        .get("content-type")
1738        .and_then(|v| v.to_str().ok())
1739        .unwrap_or("application/octet-stream");
1740    let content_type = super::ContentType::from(content_type);
1741
1742    if !status.is_client_error() && !status.is_server_error() {
1743        let content = resp.text().await?;
1744        match content_type {
1745            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1746            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephGetOsdResponse`"))),
1747            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephGetOsdResponse`")))),
1748        }
1749    } else {
1750        let content = resp.text().await?;
1751        let entity: Option<NodesCephGetOsdError> = serde_json::from_str(&content).ok();
1752        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1753    }
1754}
1755
1756/// Show the current pool status.
1757pub async fn nodes_ceph_getpool(configuration: &configuration::Configuration, name: &str, node: &str, verbose: Option<&str>) -> Result<models::NodesCephGetpoolResponse, Error<NodesCephGetpoolError>> {
1758    // add a prefix to parameters to efficiently prevent name collisions
1759    let p_path_name = name;
1760    let p_path_node = node;
1761    let p_query_verbose = verbose;
1762
1763    let uri_str = format!("{}/nodes/{node}/ceph/pool/{name}/status", configuration.base_path, name=crate::apis::urlencode(p_path_name), node=crate::apis::urlencode(p_path_node));
1764    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1765
1766    if let Some(ref param_value) = p_query_verbose {
1767        req_builder = req_builder.query(&[("verbose", &param_value.to_string())]);
1768    }
1769    if let Some(ref user_agent) = configuration.user_agent {
1770        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1771    }
1772    if let Some(ref apikey) = configuration.api_key {
1773        let key = apikey.key.clone();
1774        let value = match apikey.prefix {
1775            Some(ref prefix) => format!("{} {}", prefix, key),
1776            None => key,
1777        };
1778        req_builder = req_builder.header("Authorization", value);
1779    };
1780    if let Some(ref apikey) = configuration.api_key {
1781        let key = apikey.key.clone();
1782        let value = match apikey.prefix {
1783            Some(ref prefix) => format!("{} {}", prefix, key),
1784            None => key,
1785        };
1786        req_builder = req_builder.header("CSRFPreventionToken", value);
1787    };
1788
1789    let req = req_builder.build()?;
1790    let resp = configuration.client.execute(req).await?;
1791
1792    let status = resp.status();
1793    let content_type = resp
1794        .headers()
1795        .get("content-type")
1796        .and_then(|v| v.to_str().ok())
1797        .unwrap_or("application/octet-stream");
1798    let content_type = super::ContentType::from(content_type);
1799
1800    if !status.is_client_error() && !status.is_server_error() {
1801        let content = resp.text().await?;
1802        match content_type {
1803            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1804            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephGetpoolResponse`"))),
1805            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephGetpoolResponse`")))),
1806        }
1807    } else {
1808        let content = resp.text().await?;
1809        let entity: Option<NodesCephGetpoolError> = serde_json::from_str(&content).ok();
1810        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1811    }
1812}
1813
1814/// ceph osd in
1815pub async fn nodes_ceph_in(configuration: &configuration::Configuration, node: &str, osdid: i64) -> Result<models::NodesCephInResponse, Error<NodesCephInError>> {
1816    // add a prefix to parameters to efficiently prevent name collisions
1817    let p_path_node = node;
1818    let p_path_osdid = osdid;
1819
1820    let uri_str = format!("{}/nodes/{node}/ceph/osd/{osdid}/in", configuration.base_path, node=crate::apis::urlencode(p_path_node), osdid=p_path_osdid);
1821    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1822
1823    if let Some(ref user_agent) = configuration.user_agent {
1824        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1825    }
1826    if let Some(ref apikey) = configuration.api_key {
1827        let key = apikey.key.clone();
1828        let value = match apikey.prefix {
1829            Some(ref prefix) => format!("{} {}", prefix, key),
1830            None => key,
1831        };
1832        req_builder = req_builder.header("Authorization", value);
1833    };
1834    if let Some(ref apikey) = configuration.api_key {
1835        let key = apikey.key.clone();
1836        let value = match apikey.prefix {
1837            Some(ref prefix) => format!("{} {}", prefix, key),
1838            None => key,
1839        };
1840        req_builder = req_builder.header("CSRFPreventionToken", value);
1841    };
1842
1843    let req = req_builder.build()?;
1844    let resp = configuration.client.execute(req).await?;
1845
1846    let status = resp.status();
1847    let content_type = resp
1848        .headers()
1849        .get("content-type")
1850        .and_then(|v| v.to_str().ok())
1851        .unwrap_or("application/octet-stream");
1852    let content_type = super::ContentType::from(content_type);
1853
1854    if !status.is_client_error() && !status.is_server_error() {
1855        let content = resp.text().await?;
1856        match content_type {
1857            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1858            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephInResponse`"))),
1859            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephInResponse`")))),
1860        }
1861    } else {
1862        let content = resp.text().await?;
1863        let entity: Option<NodesCephInError> = serde_json::from_str(&content).ok();
1864        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1865    }
1866}
1867
1868/// Create the initial Ceph default configuration and set up symlinks. Idempotent on re-call: if a [global] section already exists in ceph.conf, the existing fsid / auth / pool defaults are preserved and most parameters are silently ignored.
1869pub async fn nodes_ceph_init(configuration: &configuration::Configuration, node: &str, nodes_ceph_init_request: Option<models::NodesCephInitRequest>) -> Result<models::NodesCephInitResponse, Error<NodesCephInitError>> {
1870    // add a prefix to parameters to efficiently prevent name collisions
1871    let p_path_node = node;
1872    let p_body_nodes_ceph_init_request = nodes_ceph_init_request;
1873
1874    let uri_str = format!("{}/nodes/{node}/ceph/init", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1875    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1876
1877    if let Some(ref user_agent) = configuration.user_agent {
1878        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1879    }
1880    if let Some(ref apikey) = configuration.api_key {
1881        let key = apikey.key.clone();
1882        let value = match apikey.prefix {
1883            Some(ref prefix) => format!("{} {}", prefix, key),
1884            None => key,
1885        };
1886        req_builder = req_builder.header("Authorization", value);
1887    };
1888    if let Some(ref apikey) = configuration.api_key {
1889        let key = apikey.key.clone();
1890        let value = match apikey.prefix {
1891            Some(ref prefix) => format!("{} {}", prefix, key),
1892            None => key,
1893        };
1894        req_builder = req_builder.header("CSRFPreventionToken", value);
1895    };
1896    req_builder = req_builder.json(&p_body_nodes_ceph_init_request);
1897
1898    let req = req_builder.build()?;
1899    let resp = configuration.client.execute(req).await?;
1900
1901    let status = resp.status();
1902    let content_type = resp
1903        .headers()
1904        .get("content-type")
1905        .and_then(|v| v.to_str().ok())
1906        .unwrap_or("application/octet-stream");
1907    let content_type = super::ContentType::from(content_type);
1908
1909    if !status.is_client_error() && !status.is_server_error() {
1910        let content = resp.text().await?;
1911        match content_type {
1912            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1913            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephInitResponse`"))),
1914            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephInitResponse`")))),
1915        }
1916    } else {
1917        let content = resp.text().await?;
1918        let entity: Option<NodesCephInitError> = serde_json::from_str(&content).ok();
1919        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1920    }
1921}
1922
1923/// Get Ceph monitor list.
1924pub async fn nodes_ceph_listmon(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesCephListmonResponse, Error<NodesCephListmonError>> {
1925    // add a prefix to parameters to efficiently prevent name collisions
1926    let p_path_node = node;
1927
1928    let uri_str = format!("{}/nodes/{node}/ceph/mon", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1929    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1930
1931    if let Some(ref user_agent) = configuration.user_agent {
1932        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1933    }
1934    if let Some(ref apikey) = configuration.api_key {
1935        let key = apikey.key.clone();
1936        let value = match apikey.prefix {
1937            Some(ref prefix) => format!("{} {}", prefix, key),
1938            None => key,
1939        };
1940        req_builder = req_builder.header("Authorization", value);
1941    };
1942    if let Some(ref apikey) = configuration.api_key {
1943        let key = apikey.key.clone();
1944        let value = match apikey.prefix {
1945            Some(ref prefix) => format!("{} {}", prefix, key),
1946            None => key,
1947        };
1948        req_builder = req_builder.header("CSRFPreventionToken", value);
1949    };
1950
1951    let req = req_builder.build()?;
1952    let resp = configuration.client.execute(req).await?;
1953
1954    let status = resp.status();
1955    let content_type = resp
1956        .headers()
1957        .get("content-type")
1958        .and_then(|v| v.to_str().ok())
1959        .unwrap_or("application/octet-stream");
1960    let content_type = super::ContentType::from(content_type);
1961
1962    if !status.is_client_error() && !status.is_server_error() {
1963        let content = resp.text().await?;
1964        match content_type {
1965            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1966            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephListmonResponse`"))),
1967            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephListmonResponse`")))),
1968        }
1969    } else {
1970        let content = resp.text().await?;
1971        let entity: Option<NodesCephListmonError> = serde_json::from_str(&content).ok();
1972        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1973    }
1974}
1975
1976/// Read ceph log
1977pub async fn nodes_ceph_log(configuration: &configuration::Configuration, node: &str, limit: Option<i64>, start: Option<i64>) -> Result<models::NodesCephLogResponse, Error<NodesCephLogError>> {
1978    // add a prefix to parameters to efficiently prevent name collisions
1979    let p_path_node = node;
1980    let p_query_limit = limit;
1981    let p_query_start = start;
1982
1983    let uri_str = format!("{}/nodes/{node}/ceph/log", configuration.base_path, node=crate::apis::urlencode(p_path_node));
1984    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1985
1986    if let Some(ref param_value) = p_query_limit {
1987        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
1988    }
1989    if let Some(ref param_value) = p_query_start {
1990        req_builder = req_builder.query(&[("start", &param_value.to_string())]);
1991    }
1992    if let Some(ref user_agent) = configuration.user_agent {
1993        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1994    }
1995    if let Some(ref apikey) = configuration.api_key {
1996        let key = apikey.key.clone();
1997        let value = match apikey.prefix {
1998            Some(ref prefix) => format!("{} {}", prefix, key),
1999            None => key,
2000        };
2001        req_builder = req_builder.header("Authorization", value);
2002    };
2003    if let Some(ref apikey) = configuration.api_key {
2004        let key = apikey.key.clone();
2005        let value = match apikey.prefix {
2006            Some(ref prefix) => format!("{} {}", prefix, key),
2007            None => key,
2008        };
2009        req_builder = req_builder.header("CSRFPreventionToken", value);
2010    };
2011
2012    let req = req_builder.build()?;
2013    let resp = configuration.client.execute(req).await?;
2014
2015    let status = resp.status();
2016    let content_type = resp
2017        .headers()
2018        .get("content-type")
2019        .and_then(|v| v.to_str().ok())
2020        .unwrap_or("application/octet-stream");
2021    let content_type = super::ContentType::from(content_type);
2022
2023    if !status.is_client_error() && !status.is_server_error() {
2024        let content = resp.text().await?;
2025        match content_type {
2026            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2027            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephLogResponse`"))),
2028            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephLogResponse`")))),
2029        }
2030    } else {
2031        let content = resp.text().await?;
2032        let entity: Option<NodesCephLogError> = serde_json::from_str(&content).ok();
2033        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2034    }
2035}
2036
2037/// List all pools and their settings (which are settable by the POST/PUT endpoints).
2038pub async fn nodes_ceph_lspools(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesCephLspoolsResponse, Error<NodesCephLspoolsError>> {
2039    // add a prefix to parameters to efficiently prevent name collisions
2040    let p_path_node = node;
2041
2042    let uri_str = format!("{}/nodes/{node}/ceph/pool", configuration.base_path, node=crate::apis::urlencode(p_path_node));
2043    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2044
2045    if let Some(ref user_agent) = configuration.user_agent {
2046        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2047    }
2048    if let Some(ref apikey) = configuration.api_key {
2049        let key = apikey.key.clone();
2050        let value = match apikey.prefix {
2051            Some(ref prefix) => format!("{} {}", prefix, key),
2052            None => key,
2053        };
2054        req_builder = req_builder.header("Authorization", value);
2055    };
2056    if let Some(ref apikey) = configuration.api_key {
2057        let key = apikey.key.clone();
2058        let value = match apikey.prefix {
2059            Some(ref prefix) => format!("{} {}", prefix, key),
2060            None => key,
2061        };
2062        req_builder = req_builder.header("CSRFPreventionToken", value);
2063    };
2064
2065    let req = req_builder.build()?;
2066    let resp = configuration.client.execute(req).await?;
2067
2068    let status = resp.status();
2069    let content_type = resp
2070        .headers()
2071        .get("content-type")
2072        .and_then(|v| v.to_str().ok())
2073        .unwrap_or("application/octet-stream");
2074    let content_type = super::ContentType::from(content_type);
2075
2076    if !status.is_client_error() && !status.is_server_error() {
2077        let content = resp.text().await?;
2078        match content_type {
2079            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2080            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephLspoolsResponse`"))),
2081            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephLspoolsResponse`")))),
2082        }
2083    } else {
2084        let content = resp.text().await?;
2085        let entity: Option<NodesCephLspoolsError> = serde_json::from_str(&content).ok();
2086        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2087    }
2088}
2089
2090/// Get OSD details
2091pub async fn nodes_ceph_osddetails(configuration: &configuration::Configuration, node: &str, osdid: i64) -> Result<models::NodesCephOsddetailsResponse, Error<NodesCephOsddetailsError>> {
2092    // add a prefix to parameters to efficiently prevent name collisions
2093    let p_path_node = node;
2094    let p_path_osdid = osdid;
2095
2096    let uri_str = format!("{}/nodes/{node}/ceph/osd/{osdid}/metadata", configuration.base_path, node=crate::apis::urlencode(p_path_node), osdid=p_path_osdid);
2097    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2098
2099    if let Some(ref user_agent) = configuration.user_agent {
2100        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2101    }
2102    if let Some(ref apikey) = configuration.api_key {
2103        let key = apikey.key.clone();
2104        let value = match apikey.prefix {
2105            Some(ref prefix) => format!("{} {}", prefix, key),
2106            None => key,
2107        };
2108        req_builder = req_builder.header("Authorization", value);
2109    };
2110    if let Some(ref apikey) = configuration.api_key {
2111        let key = apikey.key.clone();
2112        let value = match apikey.prefix {
2113            Some(ref prefix) => format!("{} {}", prefix, key),
2114            None => key,
2115        };
2116        req_builder = req_builder.header("CSRFPreventionToken", value);
2117    };
2118
2119    let req = req_builder.build()?;
2120    let resp = configuration.client.execute(req).await?;
2121
2122    let status = resp.status();
2123    let content_type = resp
2124        .headers()
2125        .get("content-type")
2126        .and_then(|v| v.to_str().ok())
2127        .unwrap_or("application/octet-stream");
2128    let content_type = super::ContentType::from(content_type);
2129
2130    if !status.is_client_error() && !status.is_server_error() {
2131        let content = resp.text().await?;
2132        match content_type {
2133            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2134            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephOsddetailsResponse`"))),
2135            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephOsddetailsResponse`")))),
2136        }
2137    } else {
2138        let content = resp.text().await?;
2139        let entity: Option<NodesCephOsddetailsError> = serde_json::from_str(&content).ok();
2140        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2141    }
2142}
2143
2144/// OSD index.
2145pub async fn nodes_ceph_osdindex(configuration: &configuration::Configuration, node: &str, osdid: i64) -> Result<models::NodesCephOsdindexResponse, Error<NodesCephOsdindexError>> {
2146    // add a prefix to parameters to efficiently prevent name collisions
2147    let p_path_node = node;
2148    let p_path_osdid = osdid;
2149
2150    let uri_str = format!("{}/nodes/{node}/ceph/osd/{osdid}", configuration.base_path, node=crate::apis::urlencode(p_path_node), osdid=p_path_osdid);
2151    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2152
2153    if let Some(ref user_agent) = configuration.user_agent {
2154        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2155    }
2156    if let Some(ref apikey) = configuration.api_key {
2157        let key = apikey.key.clone();
2158        let value = match apikey.prefix {
2159            Some(ref prefix) => format!("{} {}", prefix, key),
2160            None => key,
2161        };
2162        req_builder = req_builder.header("Authorization", value);
2163    };
2164    if let Some(ref apikey) = configuration.api_key {
2165        let key = apikey.key.clone();
2166        let value = match apikey.prefix {
2167            Some(ref prefix) => format!("{} {}", prefix, key),
2168            None => key,
2169        };
2170        req_builder = req_builder.header("CSRFPreventionToken", value);
2171    };
2172
2173    let req = req_builder.build()?;
2174    let resp = configuration.client.execute(req).await?;
2175
2176    let status = resp.status();
2177    let content_type = resp
2178        .headers()
2179        .get("content-type")
2180        .and_then(|v| v.to_str().ok())
2181        .unwrap_or("application/octet-stream");
2182    let content_type = super::ContentType::from(content_type);
2183
2184    if !status.is_client_error() && !status.is_server_error() {
2185        let content = resp.text().await?;
2186        match content_type {
2187            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2188            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephOsdindexResponse`"))),
2189            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephOsdindexResponse`")))),
2190        }
2191    } else {
2192        let content = resp.text().await?;
2193        let entity: Option<NodesCephOsdindexError> = serde_json::from_str(&content).ok();
2194        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2195    }
2196}
2197
2198/// Get OSD volume details
2199pub async fn nodes_ceph_osdvolume(configuration: &configuration::Configuration, node: &str, osdid: i64, r#type: Option<&str>) -> Result<models::NodesCephOsdvolumeResponse, Error<NodesCephOsdvolumeError>> {
2200    // add a prefix to parameters to efficiently prevent name collisions
2201    let p_path_node = node;
2202    let p_path_osdid = osdid;
2203    let p_query_type = r#type;
2204
2205    let uri_str = format!("{}/nodes/{node}/ceph/osd/{osdid}/lv-info", configuration.base_path, node=crate::apis::urlencode(p_path_node), osdid=p_path_osdid);
2206    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2207
2208    if let Some(ref param_value) = p_query_type {
2209        req_builder = req_builder.query(&[("type", &param_value.to_string())]);
2210    }
2211    if let Some(ref user_agent) = configuration.user_agent {
2212        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2213    }
2214    if let Some(ref apikey) = configuration.api_key {
2215        let key = apikey.key.clone();
2216        let value = match apikey.prefix {
2217            Some(ref prefix) => format!("{} {}", prefix, key),
2218            None => key,
2219        };
2220        req_builder = req_builder.header("Authorization", value);
2221    };
2222    if let Some(ref apikey) = configuration.api_key {
2223        let key = apikey.key.clone();
2224        let value = match apikey.prefix {
2225            Some(ref prefix) => format!("{} {}", prefix, key),
2226            None => key,
2227        };
2228        req_builder = req_builder.header("CSRFPreventionToken", value);
2229    };
2230
2231    let req = req_builder.build()?;
2232    let resp = configuration.client.execute(req).await?;
2233
2234    let status = resp.status();
2235    let content_type = resp
2236        .headers()
2237        .get("content-type")
2238        .and_then(|v| v.to_str().ok())
2239        .unwrap_or("application/octet-stream");
2240    let content_type = super::ContentType::from(content_type);
2241
2242    if !status.is_client_error() && !status.is_server_error() {
2243        let content = resp.text().await?;
2244        match content_type {
2245            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2246            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephOsdvolumeResponse`"))),
2247            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephOsdvolumeResponse`")))),
2248        }
2249    } else {
2250        let content = resp.text().await?;
2251        let entity: Option<NodesCephOsdvolumeError> = serde_json::from_str(&content).ok();
2252        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2253    }
2254}
2255
2256/// ceph osd out
2257pub async fn nodes_ceph_out(configuration: &configuration::Configuration, node: &str, osdid: i64) -> Result<models::NodesCephOutResponse, Error<NodesCephOutError>> {
2258    // add a prefix to parameters to efficiently prevent name collisions
2259    let p_path_node = node;
2260    let p_path_osdid = osdid;
2261
2262    let uri_str = format!("{}/nodes/{node}/ceph/osd/{osdid}/out", configuration.base_path, node=crate::apis::urlencode(p_path_node), osdid=p_path_osdid);
2263    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2264
2265    if let Some(ref user_agent) = configuration.user_agent {
2266        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2267    }
2268    if let Some(ref apikey) = configuration.api_key {
2269        let key = apikey.key.clone();
2270        let value = match apikey.prefix {
2271            Some(ref prefix) => format!("{} {}", prefix, key),
2272            None => key,
2273        };
2274        req_builder = req_builder.header("Authorization", value);
2275    };
2276    if let Some(ref apikey) = configuration.api_key {
2277        let key = apikey.key.clone();
2278        let value = match apikey.prefix {
2279            Some(ref prefix) => format!("{} {}", prefix, key),
2280            None => key,
2281        };
2282        req_builder = req_builder.header("CSRFPreventionToken", value);
2283    };
2284
2285    let req = req_builder.build()?;
2286    let resp = configuration.client.execute(req).await?;
2287
2288    let status = resp.status();
2289    let content_type = resp
2290        .headers()
2291        .get("content-type")
2292        .and_then(|v| v.to_str().ok())
2293        .unwrap_or("application/octet-stream");
2294    let content_type = super::ContentType::from(content_type);
2295
2296    if !status.is_client_error() && !status.is_server_error() {
2297        let content = resp.text().await?;
2298        match content_type {
2299            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2300            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephOutResponse`"))),
2301            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephOutResponse`")))),
2302        }
2303    } else {
2304        let content = resp.text().await?;
2305        let entity: Option<NodesCephOutError> = serde_json::from_str(&content).ok();
2306        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2307    }
2308}
2309
2310/// Pool index.
2311pub async fn nodes_ceph_poolindex(configuration: &configuration::Configuration, name: &str, node: &str) -> Result<models::NodesCephPoolindexResponse, Error<NodesCephPoolindexError>> {
2312    // add a prefix to parameters to efficiently prevent name collisions
2313    let p_path_name = name;
2314    let p_path_node = node;
2315
2316    let uri_str = format!("{}/nodes/{node}/ceph/pool/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name), node=crate::apis::urlencode(p_path_node));
2317    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2318
2319    if let Some(ref user_agent) = configuration.user_agent {
2320        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2321    }
2322    if let Some(ref apikey) = configuration.api_key {
2323        let key = apikey.key.clone();
2324        let value = match apikey.prefix {
2325            Some(ref prefix) => format!("{} {}", prefix, key),
2326            None => key,
2327        };
2328        req_builder = req_builder.header("Authorization", value);
2329    };
2330    if let Some(ref apikey) = configuration.api_key {
2331        let key = apikey.key.clone();
2332        let value = match apikey.prefix {
2333            Some(ref prefix) => format!("{} {}", prefix, key),
2334            None => key,
2335        };
2336        req_builder = req_builder.header("CSRFPreventionToken", value);
2337    };
2338
2339    let req = req_builder.build()?;
2340    let resp = configuration.client.execute(req).await?;
2341
2342    let status = resp.status();
2343    let content_type = resp
2344        .headers()
2345        .get("content-type")
2346        .and_then(|v| v.to_str().ok())
2347        .unwrap_or("application/octet-stream");
2348    let content_type = super::ContentType::from(content_type);
2349
2350    if !status.is_client_error() && !status.is_server_error() {
2351        let content = resp.text().await?;
2352        match content_type {
2353            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2354            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephPoolindexResponse`"))),
2355            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephPoolindexResponse`")))),
2356        }
2357    } else {
2358        let content = resp.text().await?;
2359        let entity: Option<NodesCephPoolindexError> = serde_json::from_str(&content).ok();
2360        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2361    }
2362}
2363
2364/// Get the Ceph configuration file.
2365pub async fn nodes_ceph_raw(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesCephRawResponse, Error<NodesCephRawError>> {
2366    // add a prefix to parameters to efficiently prevent name collisions
2367    let p_path_node = node;
2368
2369    let uri_str = format!("{}/nodes/{node}/ceph/cfg/raw", configuration.base_path, node=crate::apis::urlencode(p_path_node));
2370    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2371
2372    if let Some(ref user_agent) = configuration.user_agent {
2373        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2374    }
2375    if let Some(ref apikey) = configuration.api_key {
2376        let key = apikey.key.clone();
2377        let value = match apikey.prefix {
2378            Some(ref prefix) => format!("{} {}", prefix, key),
2379            None => key,
2380        };
2381        req_builder = req_builder.header("Authorization", value);
2382    };
2383    if let Some(ref apikey) = configuration.api_key {
2384        let key = apikey.key.clone();
2385        let value = match apikey.prefix {
2386            Some(ref prefix) => format!("{} {}", prefix, key),
2387            None => key,
2388        };
2389        req_builder = req_builder.header("CSRFPreventionToken", value);
2390    };
2391
2392    let req = req_builder.build()?;
2393    let resp = configuration.client.execute(req).await?;
2394
2395    let status = resp.status();
2396    let content_type = resp
2397        .headers()
2398        .get("content-type")
2399        .and_then(|v| v.to_str().ok())
2400        .unwrap_or("application/octet-stream");
2401    let content_type = super::ContentType::from(content_type);
2402
2403    if !status.is_client_error() && !status.is_server_error() {
2404        let content = resp.text().await?;
2405        match content_type {
2406            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2407            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephRawResponse`"))),
2408            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephRawResponse`")))),
2409        }
2410    } else {
2411        let content = resp.text().await?;
2412        let entity: Option<NodesCephRawError> = serde_json::from_str(&content).ok();
2413        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2414    }
2415}
2416
2417/// Restart ceph services.
2418pub async fn nodes_ceph_restart(configuration: &configuration::Configuration, node: &str, nodes_ceph_restart_request: Option<models::NodesCephRestartRequest>) -> Result<models::NodesCephRestartResponse, Error<NodesCephRestartError>> {
2419    // add a prefix to parameters to efficiently prevent name collisions
2420    let p_path_node = node;
2421    let p_body_nodes_ceph_restart_request = nodes_ceph_restart_request;
2422
2423    let uri_str = format!("{}/nodes/{node}/ceph/restart", configuration.base_path, node=crate::apis::urlencode(p_path_node));
2424    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2425
2426    if let Some(ref user_agent) = configuration.user_agent {
2427        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2428    }
2429    if let Some(ref apikey) = configuration.api_key {
2430        let key = apikey.key.clone();
2431        let value = match apikey.prefix {
2432            Some(ref prefix) => format!("{} {}", prefix, key),
2433            None => key,
2434        };
2435        req_builder = req_builder.header("Authorization", value);
2436    };
2437    if let Some(ref apikey) = configuration.api_key {
2438        let key = apikey.key.clone();
2439        let value = match apikey.prefix {
2440            Some(ref prefix) => format!("{} {}", prefix, key),
2441            None => key,
2442        };
2443        req_builder = req_builder.header("CSRFPreventionToken", value);
2444    };
2445    req_builder = req_builder.json(&p_body_nodes_ceph_restart_request);
2446
2447    let req = req_builder.build()?;
2448    let resp = configuration.client.execute(req).await?;
2449
2450    let status = resp.status();
2451    let content_type = resp
2452        .headers()
2453        .get("content-type")
2454        .and_then(|v| v.to_str().ok())
2455        .unwrap_or("application/octet-stream");
2456    let content_type = super::ContentType::from(content_type);
2457
2458    if !status.is_client_error() && !status.is_server_error() {
2459        let content = resp.text().await?;
2460        match content_type {
2461            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2462            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephRestartResponse`"))),
2463            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephRestartResponse`")))),
2464        }
2465    } else {
2466        let content = resp.text().await?;
2467        let entity: Option<NodesCephRestartError> = serde_json::from_str(&content).ok();
2468        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2469    }
2470}
2471
2472/// List ceph rules.
2473pub async fn nodes_ceph_rules(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesCephRulesResponse, Error<NodesCephRulesError>> {
2474    // add a prefix to parameters to efficiently prevent name collisions
2475    let p_path_node = node;
2476
2477    let uri_str = format!("{}/nodes/{node}/ceph/rules", configuration.base_path, node=crate::apis::urlencode(p_path_node));
2478    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2479
2480    if let Some(ref user_agent) = configuration.user_agent {
2481        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2482    }
2483    if let Some(ref apikey) = configuration.api_key {
2484        let key = apikey.key.clone();
2485        let value = match apikey.prefix {
2486            Some(ref prefix) => format!("{} {}", prefix, key),
2487            None => key,
2488        };
2489        req_builder = req_builder.header("Authorization", value);
2490    };
2491    if let Some(ref apikey) = configuration.api_key {
2492        let key = apikey.key.clone();
2493        let value = match apikey.prefix {
2494            Some(ref prefix) => format!("{} {}", prefix, key),
2495            None => key,
2496        };
2497        req_builder = req_builder.header("CSRFPreventionToken", value);
2498    };
2499
2500    let req = req_builder.build()?;
2501    let resp = configuration.client.execute(req).await?;
2502
2503    let status = resp.status();
2504    let content_type = resp
2505        .headers()
2506        .get("content-type")
2507        .and_then(|v| v.to_str().ok())
2508        .unwrap_or("application/octet-stream");
2509    let content_type = super::ContentType::from(content_type);
2510
2511    if !status.is_client_error() && !status.is_server_error() {
2512        let content = resp.text().await?;
2513        match content_type {
2514            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2515            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephRulesResponse`"))),
2516            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephRulesResponse`")))),
2517        }
2518    } else {
2519        let content = resp.text().await?;
2520        let entity: Option<NodesCephRulesError> = serde_json::from_str(&content).ok();
2521        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2522    }
2523}
2524
2525/// Instruct the OSD to scrub.
2526pub async fn nodes_ceph_scrub(configuration: &configuration::Configuration, node: &str, osdid: i64, nodes_ceph_scrub_request: Option<models::NodesCephScrubRequest>) -> Result<models::NodesCephScrubResponse, Error<NodesCephScrubError>> {
2527    // add a prefix to parameters to efficiently prevent name collisions
2528    let p_path_node = node;
2529    let p_path_osdid = osdid;
2530    let p_body_nodes_ceph_scrub_request = nodes_ceph_scrub_request;
2531
2532    let uri_str = format!("{}/nodes/{node}/ceph/osd/{osdid}/scrub", configuration.base_path, node=crate::apis::urlencode(p_path_node), osdid=p_path_osdid);
2533    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2534
2535    if let Some(ref user_agent) = configuration.user_agent {
2536        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2537    }
2538    if let Some(ref apikey) = configuration.api_key {
2539        let key = apikey.key.clone();
2540        let value = match apikey.prefix {
2541            Some(ref prefix) => format!("{} {}", prefix, key),
2542            None => key,
2543        };
2544        req_builder = req_builder.header("Authorization", value);
2545    };
2546    if let Some(ref apikey) = configuration.api_key {
2547        let key = apikey.key.clone();
2548        let value = match apikey.prefix {
2549            Some(ref prefix) => format!("{} {}", prefix, key),
2550            None => key,
2551        };
2552        req_builder = req_builder.header("CSRFPreventionToken", value);
2553    };
2554    req_builder = req_builder.json(&p_body_nodes_ceph_scrub_request);
2555
2556    let req = req_builder.build()?;
2557    let resp = configuration.client.execute(req).await?;
2558
2559    let status = resp.status();
2560    let content_type = resp
2561        .headers()
2562        .get("content-type")
2563        .and_then(|v| v.to_str().ok())
2564        .unwrap_or("application/octet-stream");
2565    let content_type = super::ContentType::from(content_type);
2566
2567    if !status.is_client_error() && !status.is_server_error() {
2568        let content = resp.text().await?;
2569        match content_type {
2570            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2571            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephScrubResponse`"))),
2572            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephScrubResponse`")))),
2573        }
2574    } else {
2575        let content = resp.text().await?;
2576        let entity: Option<NodesCephScrubError> = serde_json::from_str(&content).ok();
2577        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2578    }
2579}
2580
2581/// Change POOL settings
2582pub async fn nodes_ceph_setpool(configuration: &configuration::Configuration, name: &str, node: &str, nodes_ceph_setpool_request: Option<models::NodesCephSetpoolRequest>) -> Result<models::NodesCephSetpoolResponse, Error<NodesCephSetpoolError>> {
2583    // add a prefix to parameters to efficiently prevent name collisions
2584    let p_path_name = name;
2585    let p_path_node = node;
2586    let p_body_nodes_ceph_setpool_request = nodes_ceph_setpool_request;
2587
2588    let uri_str = format!("{}/nodes/{node}/ceph/pool/{name}", configuration.base_path, name=crate::apis::urlencode(p_path_name), node=crate::apis::urlencode(p_path_node));
2589    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
2590
2591    if let Some(ref user_agent) = configuration.user_agent {
2592        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2593    }
2594    if let Some(ref apikey) = configuration.api_key {
2595        let key = apikey.key.clone();
2596        let value = match apikey.prefix {
2597            Some(ref prefix) => format!("{} {}", prefix, key),
2598            None => key,
2599        };
2600        req_builder = req_builder.header("Authorization", value);
2601    };
2602    if let Some(ref apikey) = configuration.api_key {
2603        let key = apikey.key.clone();
2604        let value = match apikey.prefix {
2605            Some(ref prefix) => format!("{} {}", prefix, key),
2606            None => key,
2607        };
2608        req_builder = req_builder.header("CSRFPreventionToken", value);
2609    };
2610    req_builder = req_builder.json(&p_body_nodes_ceph_setpool_request);
2611
2612    let req = req_builder.build()?;
2613    let resp = configuration.client.execute(req).await?;
2614
2615    let status = resp.status();
2616    let content_type = resp
2617        .headers()
2618        .get("content-type")
2619        .and_then(|v| v.to_str().ok())
2620        .unwrap_or("application/octet-stream");
2621    let content_type = super::ContentType::from(content_type);
2622
2623    if !status.is_client_error() && !status.is_server_error() {
2624        let content = resp.text().await?;
2625        match content_type {
2626            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2627            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephSetpoolResponse`"))),
2628            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephSetpoolResponse`")))),
2629        }
2630    } else {
2631        let content = resp.text().await?;
2632        let entity: Option<NodesCephSetpoolError> = serde_json::from_str(&content).ok();
2633        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2634    }
2635}
2636
2637/// Start ceph services.
2638pub async fn nodes_ceph_start(configuration: &configuration::Configuration, node: &str, nodes_ceph_restart_request: Option<models::NodesCephRestartRequest>) -> Result<models::NodesCephStartResponse, Error<NodesCephStartError>> {
2639    // add a prefix to parameters to efficiently prevent name collisions
2640    let p_path_node = node;
2641    let p_body_nodes_ceph_restart_request = nodes_ceph_restart_request;
2642
2643    let uri_str = format!("{}/nodes/{node}/ceph/start", configuration.base_path, node=crate::apis::urlencode(p_path_node));
2644    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2645
2646    if let Some(ref user_agent) = configuration.user_agent {
2647        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2648    }
2649    if let Some(ref apikey) = configuration.api_key {
2650        let key = apikey.key.clone();
2651        let value = match apikey.prefix {
2652            Some(ref prefix) => format!("{} {}", prefix, key),
2653            None => key,
2654        };
2655        req_builder = req_builder.header("Authorization", value);
2656    };
2657    if let Some(ref apikey) = configuration.api_key {
2658        let key = apikey.key.clone();
2659        let value = match apikey.prefix {
2660            Some(ref prefix) => format!("{} {}", prefix, key),
2661            None => key,
2662        };
2663        req_builder = req_builder.header("CSRFPreventionToken", value);
2664    };
2665    req_builder = req_builder.json(&p_body_nodes_ceph_restart_request);
2666
2667    let req = req_builder.build()?;
2668    let resp = configuration.client.execute(req).await?;
2669
2670    let status = resp.status();
2671    let content_type = resp
2672        .headers()
2673        .get("content-type")
2674        .and_then(|v| v.to_str().ok())
2675        .unwrap_or("application/octet-stream");
2676    let content_type = super::ContentType::from(content_type);
2677
2678    if !status.is_client_error() && !status.is_server_error() {
2679        let content = resp.text().await?;
2680        match content_type {
2681            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2682            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephStartResponse`"))),
2683            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephStartResponse`")))),
2684        }
2685    } else {
2686        let content = resp.text().await?;
2687        let entity: Option<NodesCephStartError> = serde_json::from_str(&content).ok();
2688        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2689    }
2690}
2691
2692/// Get the Ceph cluster status (raw 'ceph status' output). The response is cluster-wide and identical to /cluster/ceph/status; this node-level alias exists for operator convenience.
2693pub async fn nodes_ceph_status(configuration: &configuration::Configuration, node: &str) -> Result<models::NodesCephStatusResponse, Error<NodesCephStatusError>> {
2694    // add a prefix to parameters to efficiently prevent name collisions
2695    let p_path_node = node;
2696
2697    let uri_str = format!("{}/nodes/{node}/ceph/status", configuration.base_path, node=crate::apis::urlencode(p_path_node));
2698    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2699
2700    if let Some(ref user_agent) = configuration.user_agent {
2701        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2702    }
2703    if let Some(ref apikey) = configuration.api_key {
2704        let key = apikey.key.clone();
2705        let value = match apikey.prefix {
2706            Some(ref prefix) => format!("{} {}", prefix, key),
2707            None => key,
2708        };
2709        req_builder = req_builder.header("Authorization", value);
2710    };
2711    if let Some(ref apikey) = configuration.api_key {
2712        let key = apikey.key.clone();
2713        let value = match apikey.prefix {
2714            Some(ref prefix) => format!("{} {}", prefix, key),
2715            None => key,
2716        };
2717        req_builder = req_builder.header("CSRFPreventionToken", value);
2718    };
2719
2720    let req = req_builder.build()?;
2721    let resp = configuration.client.execute(req).await?;
2722
2723    let status = resp.status();
2724    let content_type = resp
2725        .headers()
2726        .get("content-type")
2727        .and_then(|v| v.to_str().ok())
2728        .unwrap_or("application/octet-stream");
2729    let content_type = super::ContentType::from(content_type);
2730
2731    if !status.is_client_error() && !status.is_server_error() {
2732        let content = resp.text().await?;
2733        match content_type {
2734            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2735            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephStatusResponse`"))),
2736            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephStatusResponse`")))),
2737        }
2738    } else {
2739        let content = resp.text().await?;
2740        let entity: Option<NodesCephStatusError> = serde_json::from_str(&content).ok();
2741        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2742    }
2743}
2744
2745/// Stop ceph services.
2746pub async fn nodes_ceph_stop(configuration: &configuration::Configuration, node: &str, nodes_ceph_restart_request: Option<models::NodesCephRestartRequest>) -> Result<models::NodesCephStopResponse, Error<NodesCephStopError>> {
2747    // add a prefix to parameters to efficiently prevent name collisions
2748    let p_path_node = node;
2749    let p_body_nodes_ceph_restart_request = nodes_ceph_restart_request;
2750
2751    let uri_str = format!("{}/nodes/{node}/ceph/stop", configuration.base_path, node=crate::apis::urlencode(p_path_node));
2752    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
2753
2754    if let Some(ref user_agent) = configuration.user_agent {
2755        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2756    }
2757    if let Some(ref apikey) = configuration.api_key {
2758        let key = apikey.key.clone();
2759        let value = match apikey.prefix {
2760            Some(ref prefix) => format!("{} {}", prefix, key),
2761            None => key,
2762        };
2763        req_builder = req_builder.header("Authorization", value);
2764    };
2765    if let Some(ref apikey) = configuration.api_key {
2766        let key = apikey.key.clone();
2767        let value = match apikey.prefix {
2768            Some(ref prefix) => format!("{} {}", prefix, key),
2769            None => key,
2770        };
2771        req_builder = req_builder.header("CSRFPreventionToken", value);
2772    };
2773    req_builder = req_builder.json(&p_body_nodes_ceph_restart_request);
2774
2775    let req = req_builder.build()?;
2776    let resp = configuration.client.execute(req).await?;
2777
2778    let status = resp.status();
2779    let content_type = resp
2780        .headers()
2781        .get("content-type")
2782        .and_then(|v| v.to_str().ok())
2783        .unwrap_or("application/octet-stream");
2784    let content_type = super::ContentType::from(content_type);
2785
2786    if !status.is_client_error() && !status.is_server_error() {
2787        let content = resp.text().await?;
2788        match content_type {
2789            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2790            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephStopResponse`"))),
2791            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephStopResponse`")))),
2792        }
2793    } else {
2794        let content = resp.text().await?;
2795        let entity: Option<NodesCephStopError> = serde_json::from_str(&content).ok();
2796        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2797    }
2798}
2799
2800/// Get configured values from either ceph.conf or the mon config DB. Underscores in section and key names are normalised to hyphens in the response, regardless of how they're written in the source.
2801pub async fn nodes_ceph_value(configuration: &configuration::Configuration, config_keys: &str, node: &str) -> Result<models::NodesCephValueResponse, Error<NodesCephValueError>> {
2802    // add a prefix to parameters to efficiently prevent name collisions
2803    let p_query_config_keys = config_keys;
2804    let p_path_node = node;
2805
2806    let uri_str = format!("{}/nodes/{node}/ceph/cfg/value", configuration.base_path, node=crate::apis::urlencode(p_path_node));
2807    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
2808
2809    req_builder = req_builder.query(&[("config-keys", &p_query_config_keys.to_string())]);
2810    if let Some(ref user_agent) = configuration.user_agent {
2811        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
2812    }
2813    if let Some(ref apikey) = configuration.api_key {
2814        let key = apikey.key.clone();
2815        let value = match apikey.prefix {
2816            Some(ref prefix) => format!("{} {}", prefix, key),
2817            None => key,
2818        };
2819        req_builder = req_builder.header("Authorization", value);
2820    };
2821    if let Some(ref apikey) = configuration.api_key {
2822        let key = apikey.key.clone();
2823        let value = match apikey.prefix {
2824            Some(ref prefix) => format!("{} {}", prefix, key),
2825            None => key,
2826        };
2827        req_builder = req_builder.header("CSRFPreventionToken", value);
2828    };
2829
2830    let req = req_builder.build()?;
2831    let resp = configuration.client.execute(req).await?;
2832
2833    let status = resp.status();
2834    let content_type = resp
2835        .headers()
2836        .get("content-type")
2837        .and_then(|v| v.to_str().ok())
2838        .unwrap_or("application/octet-stream");
2839    let content_type = super::ContentType::from(content_type);
2840
2841    if !status.is_client_error() && !status.is_server_error() {
2842        let content = resp.text().await?;
2843        match content_type {
2844            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
2845            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::NodesCephValueResponse`"))),
2846            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::NodesCephValueResponse`")))),
2847        }
2848    } else {
2849        let content = resp.text().await?;
2850        let entity: Option<NodesCephValueError> = serde_json::from_str(&content).ok();
2851        Err(Error::ResponseError(ResponseContent { status, content, entity }))
2852    }
2853}
2854
clientapi_pve/apis/nodes_ceph_api.rs

clientapi_pve/apis/
nodes_ceph_api.rs
