clientapi_pbs/apis/
tape_drive_api.rs

1/*
2 * Proxmox Backup Server API
3 *
4 * Generated from apidoc.js. NOT an official Proxmox specification. See https://pbs.proxmox.com/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 [`tape_drive_create_barcode_label_media`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum TapeDriveCreateBarcodeLabelMediaError {
22    Status400(models::PbsError),
23    Status401(models::PbsError),
24    Status403(models::PbsError),
25    Status404(models::PbsError),
26    Status500(models::PbsError),
27    Status501(models::PbsError),
28    Status503(models::PbsError),
29    UnknownValue(serde_json::Value),
30}
31
32/// struct for typed errors of method [`tape_drive_create_catalog`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum TapeDriveCreateCatalogError {
36    Status400(models::PbsError),
37    Status401(models::PbsError),
38    Status403(models::PbsError),
39    Status404(models::PbsError),
40    Status500(models::PbsError),
41    Status501(models::PbsError),
42    Status503(models::PbsError),
43    UnknownValue(serde_json::Value),
44}
45
46/// struct for typed errors of method [`tape_drive_create_eject_media`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum TapeDriveCreateEjectMediaError {
50    Status400(models::PbsError),
51    Status401(models::PbsError),
52    Status403(models::PbsError),
53    Status404(models::PbsError),
54    Status500(models::PbsError),
55    Status501(models::PbsError),
56    Status503(models::PbsError),
57    UnknownValue(serde_json::Value),
58}
59
60/// struct for typed errors of method [`tape_drive_create_format_media`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum TapeDriveCreateFormatMediaError {
64    Status400(models::PbsError),
65    Status401(models::PbsError),
66    Status403(models::PbsError),
67    Status404(models::PbsError),
68    Status500(models::PbsError),
69    Status501(models::PbsError),
70    Status503(models::PbsError),
71    UnknownValue(serde_json::Value),
72}
73
74/// struct for typed errors of method [`tape_drive_create_label_media`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum TapeDriveCreateLabelMediaError {
78    Status400(models::PbsError),
79    Status401(models::PbsError),
80    Status403(models::PbsError),
81    Status404(models::PbsError),
82    Status500(models::PbsError),
83    Status501(models::PbsError),
84    Status503(models::PbsError),
85    UnknownValue(serde_json::Value),
86}
87
88/// struct for typed errors of method [`tape_drive_create_load_media`]
89#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum TapeDriveCreateLoadMediaError {
92    Status400(models::PbsError),
93    Status401(models::PbsError),
94    Status403(models::PbsError),
95    Status404(models::PbsError),
96    Status500(models::PbsError),
97    Status501(models::PbsError),
98    Status503(models::PbsError),
99    UnknownValue(serde_json::Value),
100}
101
102/// struct for typed errors of method [`tape_drive_create_load_slot`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum TapeDriveCreateLoadSlotError {
106    Status400(models::PbsError),
107    Status401(models::PbsError),
108    Status403(models::PbsError),
109    Status404(models::PbsError),
110    Status500(models::PbsError),
111    Status501(models::PbsError),
112    Status503(models::PbsError),
113    UnknownValue(serde_json::Value),
114}
115
116/// struct for typed errors of method [`tape_drive_create_restore_key`]
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum TapeDriveCreateRestoreKeyError {
120    Status400(models::PbsError),
121    Status401(models::PbsError),
122    Status403(models::PbsError),
123    Status404(models::PbsError),
124    Status500(models::PbsError),
125    Status501(models::PbsError),
126    Status503(models::PbsError),
127    UnknownValue(serde_json::Value),
128}
129
130/// struct for typed errors of method [`tape_drive_create_rewind`]
131#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum TapeDriveCreateRewindError {
134    Status400(models::PbsError),
135    Status401(models::PbsError),
136    Status403(models::PbsError),
137    Status404(models::PbsError),
138    Status500(models::PbsError),
139    Status501(models::PbsError),
140    Status503(models::PbsError),
141    UnknownValue(serde_json::Value),
142}
143
144/// struct for typed errors of method [`tape_drive_create_unload`]
145#[derive(Debug, Clone, Serialize, Deserialize)]
146#[serde(untagged)]
147pub enum TapeDriveCreateUnloadError {
148    Status400(models::PbsError),
149    Status401(models::PbsError),
150    Status403(models::PbsError),
151    Status404(models::PbsError),
152    Status500(models::PbsError),
153    Status501(models::PbsError),
154    Status503(models::PbsError),
155    UnknownValue(serde_json::Value),
156}
157
158/// struct for typed errors of method [`tape_drive_get_cartridge_memory`]
159#[derive(Debug, Clone, Serialize, Deserialize)]
160#[serde(untagged)]
161pub enum TapeDriveGetCartridgeMemoryError {
162    Status400(models::PbsError),
163    Status401(models::PbsError),
164    Status403(models::PbsError),
165    Status404(models::PbsError),
166    Status500(models::PbsError),
167    Status501(models::PbsError),
168    Status503(models::PbsError),
169    UnknownValue(serde_json::Value),
170}
171
172/// struct for typed errors of method [`tape_drive_get_drive`]
173#[derive(Debug, Clone, Serialize, Deserialize)]
174#[serde(untagged)]
175pub enum TapeDriveGetDriveError {
176    Status400(models::PbsError),
177    Status401(models::PbsError),
178    Status403(models::PbsError),
179    Status404(models::PbsError),
180    Status500(models::PbsError),
181    Status501(models::PbsError),
182    Status503(models::PbsError),
183    UnknownValue(serde_json::Value),
184}
185
186/// struct for typed errors of method [`tape_drive_get_inventory`]
187#[derive(Debug, Clone, Serialize, Deserialize)]
188#[serde(untagged)]
189pub enum TapeDriveGetInventoryError {
190    Status400(models::PbsError),
191    Status401(models::PbsError),
192    Status403(models::PbsError),
193    Status404(models::PbsError),
194    Status500(models::PbsError),
195    Status501(models::PbsError),
196    Status503(models::PbsError),
197    UnknownValue(serde_json::Value),
198}
199
200/// struct for typed errors of method [`tape_drive_get_read_label`]
201#[derive(Debug, Clone, Serialize, Deserialize)]
202#[serde(untagged)]
203pub enum TapeDriveGetReadLabelError {
204    Status400(models::PbsError),
205    Status401(models::PbsError),
206    Status403(models::PbsError),
207    Status404(models::PbsError),
208    Status500(models::PbsError),
209    Status501(models::PbsError),
210    Status503(models::PbsError),
211    UnknownValue(serde_json::Value),
212}
213
214/// struct for typed errors of method [`tape_drive_get_status`]
215#[derive(Debug, Clone, Serialize, Deserialize)]
216#[serde(untagged)]
217pub enum TapeDriveGetStatusError {
218    Status400(models::PbsError),
219    Status401(models::PbsError),
220    Status403(models::PbsError),
221    Status404(models::PbsError),
222    Status500(models::PbsError),
223    Status501(models::PbsError),
224    Status503(models::PbsError),
225    UnknownValue(serde_json::Value),
226}
227
228/// struct for typed errors of method [`tape_drive_get_tape_drive_by_drive`]
229#[derive(Debug, Clone, Serialize, Deserialize)]
230#[serde(untagged)]
231pub enum TapeDriveGetTapeDriveByDriveError {
232    Status400(models::PbsError),
233    Status401(models::PbsError),
234    Status403(models::PbsError),
235    Status404(models::PbsError),
236    Status500(models::PbsError),
237    Status501(models::PbsError),
238    Status503(models::PbsError),
239    UnknownValue(serde_json::Value),
240}
241
242/// struct for typed errors of method [`tape_drive_get_volume_statistics`]
243#[derive(Debug, Clone, Serialize, Deserialize)]
244#[serde(untagged)]
245pub enum TapeDriveGetVolumeStatisticsError {
246    Status400(models::PbsError),
247    Status401(models::PbsError),
248    Status403(models::PbsError),
249    Status404(models::PbsError),
250    Status500(models::PbsError),
251    Status501(models::PbsError),
252    Status503(models::PbsError),
253    UnknownValue(serde_json::Value),
254}
255
256/// struct for typed errors of method [`tape_drive_update_clean`]
257#[derive(Debug, Clone, Serialize, Deserialize)]
258#[serde(untagged)]
259pub enum TapeDriveUpdateCleanError {
260    Status400(models::PbsError),
261    Status401(models::PbsError),
262    Status403(models::PbsError),
263    Status404(models::PbsError),
264    Status500(models::PbsError),
265    Status501(models::PbsError),
266    Status503(models::PbsError),
267    UnknownValue(serde_json::Value),
268}
269
270/// struct for typed errors of method [`tape_drive_update_export_media`]
271#[derive(Debug, Clone, Serialize, Deserialize)]
272#[serde(untagged)]
273pub enum TapeDriveUpdateExportMediaError {
274    Status400(models::PbsError),
275    Status401(models::PbsError),
276    Status403(models::PbsError),
277    Status404(models::PbsError),
278    Status500(models::PbsError),
279    Status501(models::PbsError),
280    Status503(models::PbsError),
281    UnknownValue(serde_json::Value),
282}
283
284/// struct for typed errors of method [`tape_drive_update_inventory`]
285#[derive(Debug, Clone, Serialize, Deserialize)]
286#[serde(untagged)]
287pub enum TapeDriveUpdateInventoryError {
288    Status400(models::PbsError),
289    Status401(models::PbsError),
290    Status403(models::PbsError),
291    Status404(models::PbsError),
292    Status500(models::PbsError),
293    Status501(models::PbsError),
294    Status503(models::PbsError),
295    UnknownValue(serde_json::Value),
296}
297
298
299/// Label media with barcodes from changer device
300pub async fn tape_drive_create_barcode_label_media(configuration: &configuration::Configuration, drive: &str, tape_drive_create_barcode_label_media_request: Option<models::TapeDriveCreateBarcodeLabelMediaRequest>) -> Result<models::TapeDriveCreateBarcodeLabelMediaResponse, Error<TapeDriveCreateBarcodeLabelMediaError>> {
301    // add a prefix to parameters to efficiently prevent name collisions
302    let p_path_drive = drive;
303    let p_body_tape_drive_create_barcode_label_media_request = tape_drive_create_barcode_label_media_request;
304
305    let uri_str = format!("{}/tape/drive/{drive}/barcode-label-media", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
306    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
307
308    if let Some(ref user_agent) = configuration.user_agent {
309        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
310    }
311    if let Some(ref apikey) = configuration.api_key {
312        let key = apikey.key.clone();
313        let value = match apikey.prefix {
314            Some(ref prefix) => format!("{} {}", prefix, key),
315            None => key,
316        };
317        req_builder = req_builder.header("Authorization", value);
318    };
319    if let Some(ref apikey) = configuration.api_key {
320        let key = apikey.key.clone();
321        let value = match apikey.prefix {
322            Some(ref prefix) => format!("{} {}", prefix, key),
323            None => key,
324        };
325        req_builder = req_builder.header("CSRFPreventionToken", value);
326    };
327    req_builder = req_builder.json(&p_body_tape_drive_create_barcode_label_media_request);
328
329    let req = req_builder.build()?;
330    let resp = configuration.client.execute(req).await?;
331
332    let status = resp.status();
333    let content_type = resp
334        .headers()
335        .get("content-type")
336        .and_then(|v| v.to_str().ok())
337        .unwrap_or("application/octet-stream");
338    let content_type = super::ContentType::from(content_type);
339
340    if !status.is_client_error() && !status.is_server_error() {
341        let content = resp.text().await?;
342        match content_type {
343            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
344            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveCreateBarcodeLabelMediaResponse`"))),
345            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::TapeDriveCreateBarcodeLabelMediaResponse`")))),
346        }
347    } else {
348        let content = resp.text().await?;
349        let entity: Option<TapeDriveCreateBarcodeLabelMediaError> = serde_json::from_str(&content).ok();
350        Err(Error::ResponseError(ResponseContent { status, content, entity }))
351    }
352}
353
354/// Scan media and record content
355pub async fn tape_drive_create_catalog(configuration: &configuration::Configuration, drive: &str, tape_drive_create_catalog_request: Option<models::TapeDriveCreateCatalogRequest>) -> Result<models::TapeDriveCreateCatalogResponse, Error<TapeDriveCreateCatalogError>> {
356    // add a prefix to parameters to efficiently prevent name collisions
357    let p_path_drive = drive;
358    let p_body_tape_drive_create_catalog_request = tape_drive_create_catalog_request;
359
360    let uri_str = format!("{}/tape/drive/{drive}/catalog", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
361    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
362
363    if let Some(ref user_agent) = configuration.user_agent {
364        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
365    }
366    if let Some(ref apikey) = configuration.api_key {
367        let key = apikey.key.clone();
368        let value = match apikey.prefix {
369            Some(ref prefix) => format!("{} {}", prefix, key),
370            None => key,
371        };
372        req_builder = req_builder.header("Authorization", value);
373    };
374    if let Some(ref apikey) = configuration.api_key {
375        let key = apikey.key.clone();
376        let value = match apikey.prefix {
377            Some(ref prefix) => format!("{} {}", prefix, key),
378            None => key,
379        };
380        req_builder = req_builder.header("CSRFPreventionToken", value);
381    };
382    req_builder = req_builder.json(&p_body_tape_drive_create_catalog_request);
383
384    let req = req_builder.build()?;
385    let resp = configuration.client.execute(req).await?;
386
387    let status = resp.status();
388    let content_type = resp
389        .headers()
390        .get("content-type")
391        .and_then(|v| v.to_str().ok())
392        .unwrap_or("application/octet-stream");
393    let content_type = super::ContentType::from(content_type);
394
395    if !status.is_client_error() && !status.is_server_error() {
396        let content = resp.text().await?;
397        match content_type {
398            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
399            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveCreateCatalogResponse`"))),
400            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::TapeDriveCreateCatalogResponse`")))),
401        }
402    } else {
403        let content = resp.text().await?;
404        let entity: Option<TapeDriveCreateCatalogError> = serde_json::from_str(&content).ok();
405        Err(Error::ResponseError(ResponseContent { status, content, entity }))
406    }
407}
408
409/// Eject/Unload drive media
410pub async fn tape_drive_create_eject_media(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveCreateEjectMediaResponse, Error<TapeDriveCreateEjectMediaError>> {
411    // add a prefix to parameters to efficiently prevent name collisions
412    let p_path_drive = drive;
413
414    let uri_str = format!("{}/tape/drive/{drive}/eject-media", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
415    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
416
417    if let Some(ref user_agent) = configuration.user_agent {
418        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
419    }
420    if let Some(ref apikey) = configuration.api_key {
421        let key = apikey.key.clone();
422        let value = match apikey.prefix {
423            Some(ref prefix) => format!("{} {}", prefix, key),
424            None => key,
425        };
426        req_builder = req_builder.header("Authorization", value);
427    };
428    if let Some(ref apikey) = configuration.api_key {
429        let key = apikey.key.clone();
430        let value = match apikey.prefix {
431            Some(ref prefix) => format!("{} {}", prefix, key),
432            None => key,
433        };
434        req_builder = req_builder.header("CSRFPreventionToken", value);
435    };
436
437    let req = req_builder.build()?;
438    let resp = configuration.client.execute(req).await?;
439
440    let status = resp.status();
441    let content_type = resp
442        .headers()
443        .get("content-type")
444        .and_then(|v| v.to_str().ok())
445        .unwrap_or("application/octet-stream");
446    let content_type = super::ContentType::from(content_type);
447
448    if !status.is_client_error() && !status.is_server_error() {
449        let content = resp.text().await?;
450        match content_type {
451            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
452            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveCreateEjectMediaResponse`"))),
453            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::TapeDriveCreateEjectMediaResponse`")))),
454        }
455    } else {
456        let content = resp.text().await?;
457        let entity: Option<TapeDriveCreateEjectMediaError> = serde_json::from_str(&content).ok();
458        Err(Error::ResponseError(ResponseContent { status, content, entity }))
459    }
460}
461
462/// Format media. Check for label-text if given (cancels if wrong media).
463pub async fn tape_drive_create_format_media(configuration: &configuration::Configuration, drive: &str, tape_drive_create_format_media_request: Option<models::TapeDriveCreateFormatMediaRequest>) -> Result<models::TapeDriveCreateFormatMediaResponse, Error<TapeDriveCreateFormatMediaError>> {
464    // add a prefix to parameters to efficiently prevent name collisions
465    let p_path_drive = drive;
466    let p_body_tape_drive_create_format_media_request = tape_drive_create_format_media_request;
467
468    let uri_str = format!("{}/tape/drive/{drive}/format-media", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
469    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
470
471    if let Some(ref user_agent) = configuration.user_agent {
472        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
473    }
474    if let Some(ref apikey) = configuration.api_key {
475        let key = apikey.key.clone();
476        let value = match apikey.prefix {
477            Some(ref prefix) => format!("{} {}", prefix, key),
478            None => key,
479        };
480        req_builder = req_builder.header("Authorization", value);
481    };
482    if let Some(ref apikey) = configuration.api_key {
483        let key = apikey.key.clone();
484        let value = match apikey.prefix {
485            Some(ref prefix) => format!("{} {}", prefix, key),
486            None => key,
487        };
488        req_builder = req_builder.header("CSRFPreventionToken", value);
489    };
490    req_builder = req_builder.json(&p_body_tape_drive_create_format_media_request);
491
492    let req = req_builder.build()?;
493    let resp = configuration.client.execute(req).await?;
494
495    let status = resp.status();
496    let content_type = resp
497        .headers()
498        .get("content-type")
499        .and_then(|v| v.to_str().ok())
500        .unwrap_or("application/octet-stream");
501    let content_type = super::ContentType::from(content_type);
502
503    if !status.is_client_error() && !status.is_server_error() {
504        let content = resp.text().await?;
505        match content_type {
506            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
507            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveCreateFormatMediaResponse`"))),
508            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::TapeDriveCreateFormatMediaResponse`")))),
509        }
510    } else {
511        let content = resp.text().await?;
512        let entity: Option<TapeDriveCreateFormatMediaError> = serde_json::from_str(&content).ok();
513        Err(Error::ResponseError(ResponseContent { status, content, entity }))
514    }
515}
516
517/// Label media  Write a new media label to the media in 'drive'. The media is assigned to the specified 'pool', or else to the free media pool.  Note: The media need to be empty (you may want to format it first).
518pub async fn tape_drive_create_label_media(configuration: &configuration::Configuration, drive: &str, tape_drive_create_label_media_request: models::TapeDriveCreateLabelMediaRequest) -> Result<models::TapeDriveCreateLabelMediaResponse, Error<TapeDriveCreateLabelMediaError>> {
519    // add a prefix to parameters to efficiently prevent name collisions
520    let p_path_drive = drive;
521    let p_body_tape_drive_create_label_media_request = tape_drive_create_label_media_request;
522
523    let uri_str = format!("{}/tape/drive/{drive}/label-media", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
524    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
525
526    if let Some(ref user_agent) = configuration.user_agent {
527        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
528    }
529    if let Some(ref apikey) = configuration.api_key {
530        let key = apikey.key.clone();
531        let value = match apikey.prefix {
532            Some(ref prefix) => format!("{} {}", prefix, key),
533            None => key,
534        };
535        req_builder = req_builder.header("Authorization", value);
536    };
537    if let Some(ref apikey) = configuration.api_key {
538        let key = apikey.key.clone();
539        let value = match apikey.prefix {
540            Some(ref prefix) => format!("{} {}", prefix, key),
541            None => key,
542        };
543        req_builder = req_builder.header("CSRFPreventionToken", value);
544    };
545    req_builder = req_builder.json(&p_body_tape_drive_create_label_media_request);
546
547    let req = req_builder.build()?;
548    let resp = configuration.client.execute(req).await?;
549
550    let status = resp.status();
551    let content_type = resp
552        .headers()
553        .get("content-type")
554        .and_then(|v| v.to_str().ok())
555        .unwrap_or("application/octet-stream");
556    let content_type = super::ContentType::from(content_type);
557
558    if !status.is_client_error() && !status.is_server_error() {
559        let content = resp.text().await?;
560        match content_type {
561            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
562            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveCreateLabelMediaResponse`"))),
563            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::TapeDriveCreateLabelMediaResponse`")))),
564        }
565    } else {
566        let content = resp.text().await?;
567        let entity: Option<TapeDriveCreateLabelMediaError> = serde_json::from_str(&content).ok();
568        Err(Error::ResponseError(ResponseContent { status, content, entity }))
569    }
570}
571
572/// Load media with specified label  Issue a media load request to the associated changer device.
573pub async fn tape_drive_create_load_media(configuration: &configuration::Configuration, drive: &str, tape_drive_update_export_media_request: models::TapeDriveUpdateExportMediaRequest) -> Result<models::TapeDriveCreateLoadMediaResponse, Error<TapeDriveCreateLoadMediaError>> {
574    // add a prefix to parameters to efficiently prevent name collisions
575    let p_path_drive = drive;
576    let p_body_tape_drive_update_export_media_request = tape_drive_update_export_media_request;
577
578    let uri_str = format!("{}/tape/drive/{drive}/load-media", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
579    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
580
581    if let Some(ref user_agent) = configuration.user_agent {
582        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
583    }
584    if let Some(ref apikey) = configuration.api_key {
585        let key = apikey.key.clone();
586        let value = match apikey.prefix {
587            Some(ref prefix) => format!("{} {}", prefix, key),
588            None => key,
589        };
590        req_builder = req_builder.header("Authorization", value);
591    };
592    if let Some(ref apikey) = configuration.api_key {
593        let key = apikey.key.clone();
594        let value = match apikey.prefix {
595            Some(ref prefix) => format!("{} {}", prefix, key),
596            None => key,
597        };
598        req_builder = req_builder.header("CSRFPreventionToken", value);
599    };
600    req_builder = req_builder.json(&p_body_tape_drive_update_export_media_request);
601
602    let req = req_builder.build()?;
603    let resp = configuration.client.execute(req).await?;
604
605    let status = resp.status();
606    let content_type = resp
607        .headers()
608        .get("content-type")
609        .and_then(|v| v.to_str().ok())
610        .unwrap_or("application/octet-stream");
611    let content_type = super::ContentType::from(content_type);
612
613    if !status.is_client_error() && !status.is_server_error() {
614        let content = resp.text().await?;
615        match content_type {
616            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
617            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveCreateLoadMediaResponse`"))),
618            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::TapeDriveCreateLoadMediaResponse`")))),
619        }
620    } else {
621        let content = resp.text().await?;
622        let entity: Option<TapeDriveCreateLoadMediaError> = serde_json::from_str(&content).ok();
623        Err(Error::ResponseError(ResponseContent { status, content, entity }))
624    }
625}
626
627/// Load media from the specified slot  Issue a media load request to the associated changer device.
628pub async fn tape_drive_create_load_slot(configuration: &configuration::Configuration, drive: &str, tape_drive_create_load_slot_request: models::TapeDriveCreateLoadSlotRequest) -> Result<models::TapeDriveCreateLoadSlotResponse, Error<TapeDriveCreateLoadSlotError>> {
629    // add a prefix to parameters to efficiently prevent name collisions
630    let p_path_drive = drive;
631    let p_body_tape_drive_create_load_slot_request = tape_drive_create_load_slot_request;
632
633    let uri_str = format!("{}/tape/drive/{drive}/load-slot", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
634    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
635
636    if let Some(ref user_agent) = configuration.user_agent {
637        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
638    }
639    if let Some(ref apikey) = configuration.api_key {
640        let key = apikey.key.clone();
641        let value = match apikey.prefix {
642            Some(ref prefix) => format!("{} {}", prefix, key),
643            None => key,
644        };
645        req_builder = req_builder.header("Authorization", value);
646    };
647    if let Some(ref apikey) = configuration.api_key {
648        let key = apikey.key.clone();
649        let value = match apikey.prefix {
650            Some(ref prefix) => format!("{} {}", prefix, key),
651            None => key,
652        };
653        req_builder = req_builder.header("CSRFPreventionToken", value);
654    };
655    req_builder = req_builder.json(&p_body_tape_drive_create_load_slot_request);
656
657    let req = req_builder.build()?;
658    let resp = configuration.client.execute(req).await?;
659
660    let status = resp.status();
661    let content_type = resp
662        .headers()
663        .get("content-type")
664        .and_then(|v| v.to_str().ok())
665        .unwrap_or("application/octet-stream");
666    let content_type = super::ContentType::from(content_type);
667
668    if !status.is_client_error() && !status.is_server_error() {
669        let content = resp.text().await?;
670        match content_type {
671            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
672            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveCreateLoadSlotResponse`"))),
673            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::TapeDriveCreateLoadSlotResponse`")))),
674        }
675    } else {
676        let content = resp.text().await?;
677        let entity: Option<TapeDriveCreateLoadSlotError> = serde_json::from_str(&content).ok();
678        Err(Error::ResponseError(ResponseContent { status, content, entity }))
679    }
680}
681
682/// Try to restore a tape encryption key
683pub async fn tape_drive_create_restore_key(configuration: &configuration::Configuration, drive: &str, tape_drive_create_restore_key_request: models::TapeDriveCreateRestoreKeyRequest) -> Result<models::TapeDriveCreateRestoreKeyResponse, Error<TapeDriveCreateRestoreKeyError>> {
684    // add a prefix to parameters to efficiently prevent name collisions
685    let p_path_drive = drive;
686    let p_body_tape_drive_create_restore_key_request = tape_drive_create_restore_key_request;
687
688    let uri_str = format!("{}/tape/drive/{drive}/restore-key", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
689    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
690
691    if let Some(ref user_agent) = configuration.user_agent {
692        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
693    }
694    if let Some(ref apikey) = configuration.api_key {
695        let key = apikey.key.clone();
696        let value = match apikey.prefix {
697            Some(ref prefix) => format!("{} {}", prefix, key),
698            None => key,
699        };
700        req_builder = req_builder.header("Authorization", value);
701    };
702    if let Some(ref apikey) = configuration.api_key {
703        let key = apikey.key.clone();
704        let value = match apikey.prefix {
705            Some(ref prefix) => format!("{} {}", prefix, key),
706            None => key,
707        };
708        req_builder = req_builder.header("CSRFPreventionToken", value);
709    };
710    req_builder = req_builder.json(&p_body_tape_drive_create_restore_key_request);
711
712    let req = req_builder.build()?;
713    let resp = configuration.client.execute(req).await?;
714
715    let status = resp.status();
716    let content_type = resp
717        .headers()
718        .get("content-type")
719        .and_then(|v| v.to_str().ok())
720        .unwrap_or("application/octet-stream");
721    let content_type = super::ContentType::from(content_type);
722
723    if !status.is_client_error() && !status.is_server_error() {
724        let content = resp.text().await?;
725        match content_type {
726            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
727            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveCreateRestoreKeyResponse`"))),
728            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::TapeDriveCreateRestoreKeyResponse`")))),
729        }
730    } else {
731        let content = resp.text().await?;
732        let entity: Option<TapeDriveCreateRestoreKeyError> = serde_json::from_str(&content).ok();
733        Err(Error::ResponseError(ResponseContent { status, content, entity }))
734    }
735}
736
737/// Rewind tape
738pub async fn tape_drive_create_rewind(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveCreateRewindResponse, Error<TapeDriveCreateRewindError>> {
739    // add a prefix to parameters to efficiently prevent name collisions
740    let p_path_drive = drive;
741
742    let uri_str = format!("{}/tape/drive/{drive}/rewind", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
743    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
744
745    if let Some(ref user_agent) = configuration.user_agent {
746        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
747    }
748    if let Some(ref apikey) = configuration.api_key {
749        let key = apikey.key.clone();
750        let value = match apikey.prefix {
751            Some(ref prefix) => format!("{} {}", prefix, key),
752            None => key,
753        };
754        req_builder = req_builder.header("Authorization", value);
755    };
756    if let Some(ref apikey) = configuration.api_key {
757        let key = apikey.key.clone();
758        let value = match apikey.prefix {
759            Some(ref prefix) => format!("{} {}", prefix, key),
760            None => key,
761        };
762        req_builder = req_builder.header("CSRFPreventionToken", value);
763    };
764
765    let req = req_builder.build()?;
766    let resp = configuration.client.execute(req).await?;
767
768    let status = resp.status();
769    let content_type = resp
770        .headers()
771        .get("content-type")
772        .and_then(|v| v.to_str().ok())
773        .unwrap_or("application/octet-stream");
774    let content_type = super::ContentType::from(content_type);
775
776    if !status.is_client_error() && !status.is_server_error() {
777        let content = resp.text().await?;
778        match content_type {
779            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
780            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveCreateRewindResponse`"))),
781            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::TapeDriveCreateRewindResponse`")))),
782        }
783    } else {
784        let content = resp.text().await?;
785        let entity: Option<TapeDriveCreateRewindError> = serde_json::from_str(&content).ok();
786        Err(Error::ResponseError(ResponseContent { status, content, entity }))
787    }
788}
789
790/// Unload media via changer
791pub async fn tape_drive_create_unload(configuration: &configuration::Configuration, drive: &str, tape_drive_create_unload_request: Option<models::TapeDriveCreateUnloadRequest>) -> Result<models::TapeDriveCreateUnloadResponse, Error<TapeDriveCreateUnloadError>> {
792    // add a prefix to parameters to efficiently prevent name collisions
793    let p_path_drive = drive;
794    let p_body_tape_drive_create_unload_request = tape_drive_create_unload_request;
795
796    let uri_str = format!("{}/tape/drive/{drive}/unload", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
797    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
798
799    if let Some(ref user_agent) = configuration.user_agent {
800        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
801    }
802    if let Some(ref apikey) = configuration.api_key {
803        let key = apikey.key.clone();
804        let value = match apikey.prefix {
805            Some(ref prefix) => format!("{} {}", prefix, key),
806            None => key,
807        };
808        req_builder = req_builder.header("Authorization", value);
809    };
810    if let Some(ref apikey) = configuration.api_key {
811        let key = apikey.key.clone();
812        let value = match apikey.prefix {
813            Some(ref prefix) => format!("{} {}", prefix, key),
814            None => key,
815        };
816        req_builder = req_builder.header("CSRFPreventionToken", value);
817    };
818    req_builder = req_builder.json(&p_body_tape_drive_create_unload_request);
819
820    let req = req_builder.build()?;
821    let resp = configuration.client.execute(req).await?;
822
823    let status = resp.status();
824    let content_type = resp
825        .headers()
826        .get("content-type")
827        .and_then(|v| v.to_str().ok())
828        .unwrap_or("application/octet-stream");
829    let content_type = super::ContentType::from(content_type);
830
831    if !status.is_client_error() && !status.is_server_error() {
832        let content = resp.text().await?;
833        match content_type {
834            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
835            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveCreateUnloadResponse`"))),
836            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::TapeDriveCreateUnloadResponse`")))),
837        }
838    } else {
839        let content = resp.text().await?;
840        let entity: Option<TapeDriveCreateUnloadError> = serde_json::from_str(&content).ok();
841        Err(Error::ResponseError(ResponseContent { status, content, entity }))
842    }
843}
844
845/// Read Cartridge Memory (Medium auxiliary memory attributes)
846pub async fn tape_drive_get_cartridge_memory(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveGetCartridgeMemoryResponse, Error<TapeDriveGetCartridgeMemoryError>> {
847    // add a prefix to parameters to efficiently prevent name collisions
848    let p_path_drive = drive;
849
850    let uri_str = format!("{}/tape/drive/{drive}/cartridge-memory", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
851    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
852
853    if let Some(ref user_agent) = configuration.user_agent {
854        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
855    }
856    if let Some(ref apikey) = configuration.api_key {
857        let key = apikey.key.clone();
858        let value = match apikey.prefix {
859            Some(ref prefix) => format!("{} {}", prefix, key),
860            None => key,
861        };
862        req_builder = req_builder.header("Authorization", value);
863    };
864    if let Some(ref apikey) = configuration.api_key {
865        let key = apikey.key.clone();
866        let value = match apikey.prefix {
867            Some(ref prefix) => format!("{} {}", prefix, key),
868            None => key,
869        };
870        req_builder = req_builder.header("CSRFPreventionToken", value);
871    };
872
873    let req = req_builder.build()?;
874    let resp = configuration.client.execute(req).await?;
875
876    let status = resp.status();
877    let content_type = resp
878        .headers()
879        .get("content-type")
880        .and_then(|v| v.to_str().ok())
881        .unwrap_or("application/octet-stream");
882    let content_type = super::ContentType::from(content_type);
883
884    if !status.is_client_error() && !status.is_server_error() {
885        let content = resp.text().await?;
886        match content_type {
887            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
888            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveGetCartridgeMemoryResponse`"))),
889            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::TapeDriveGetCartridgeMemoryResponse`")))),
890        }
891    } else {
892        let content = resp.text().await?;
893        let entity: Option<TapeDriveGetCartridgeMemoryError> = serde_json::from_str(&content).ok();
894        Err(Error::ResponseError(ResponseContent { status, content, entity }))
895    }
896}
897
898/// List drives  Permissions: List configured tape drives filtered by Tape.Audit privileges
899pub async fn tape_drive_get_drive(configuration: &configuration::Configuration, changer: Option<&str>, query_activity: Option<bool>) -> Result<models::TapeDriveGetDriveResponse, Error<TapeDriveGetDriveError>> {
900    // add a prefix to parameters to efficiently prevent name collisions
901    let p_query_changer = changer;
902    let p_query_query_activity = query_activity;
903
904    let uri_str = format!("{}/tape/drive", configuration.base_path);
905    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
906
907    if let Some(ref param_value) = p_query_changer {
908        req_builder = req_builder.query(&[("changer", &param_value.to_string())]);
909    }
910    if let Some(ref param_value) = p_query_query_activity {
911        req_builder = req_builder.query(&[("query-activity", &param_value.to_string())]);
912    }
913    if let Some(ref user_agent) = configuration.user_agent {
914        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
915    }
916    if let Some(ref apikey) = configuration.api_key {
917        let key = apikey.key.clone();
918        let value = match apikey.prefix {
919            Some(ref prefix) => format!("{} {}", prefix, key),
920            None => key,
921        };
922        req_builder = req_builder.header("Authorization", value);
923    };
924    if let Some(ref apikey) = configuration.api_key {
925        let key = apikey.key.clone();
926        let value = match apikey.prefix {
927            Some(ref prefix) => format!("{} {}", prefix, key),
928            None => key,
929        };
930        req_builder = req_builder.header("CSRFPreventionToken", value);
931    };
932
933    let req = req_builder.build()?;
934    let resp = configuration.client.execute(req).await?;
935
936    let status = resp.status();
937    let content_type = resp
938        .headers()
939        .get("content-type")
940        .and_then(|v| v.to_str().ok())
941        .unwrap_or("application/octet-stream");
942    let content_type = super::ContentType::from(content_type);
943
944    if !status.is_client_error() && !status.is_server_error() {
945        let content = resp.text().await?;
946        match content_type {
947            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
948            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveGetDriveResponse`"))),
949            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::TapeDriveGetDriveResponse`")))),
950        }
951    } else {
952        let content = resp.text().await?;
953        let entity: Option<TapeDriveGetDriveError> = serde_json::from_str(&content).ok();
954        Err(Error::ResponseError(ResponseContent { status, content, entity }))
955    }
956}
957
958/// List known media labels (Changer Inventory)  Note: Only useful for drives with associated changer device.  This method queries the changer to get a list of media labels.  Note: This updates the media online status.
959pub async fn tape_drive_get_inventory(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveGetInventoryResponse, Error<TapeDriveGetInventoryError>> {
960    // add a prefix to parameters to efficiently prevent name collisions
961    let p_path_drive = drive;
962
963    let uri_str = format!("{}/tape/drive/{drive}/inventory", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
964    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
965
966    if let Some(ref user_agent) = configuration.user_agent {
967        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
968    }
969    if let Some(ref apikey) = configuration.api_key {
970        let key = apikey.key.clone();
971        let value = match apikey.prefix {
972            Some(ref prefix) => format!("{} {}", prefix, key),
973            None => key,
974        };
975        req_builder = req_builder.header("Authorization", value);
976    };
977    if let Some(ref apikey) = configuration.api_key {
978        let key = apikey.key.clone();
979        let value = match apikey.prefix {
980            Some(ref prefix) => format!("{} {}", prefix, key),
981            None => key,
982        };
983        req_builder = req_builder.header("CSRFPreventionToken", value);
984    };
985
986    let req = req_builder.build()?;
987    let resp = configuration.client.execute(req).await?;
988
989    let status = resp.status();
990    let content_type = resp
991        .headers()
992        .get("content-type")
993        .and_then(|v| v.to_str().ok())
994        .unwrap_or("application/octet-stream");
995    let content_type = super::ContentType::from(content_type);
996
997    if !status.is_client_error() && !status.is_server_error() {
998        let content = resp.text().await?;
999        match content_type {
1000            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1001            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveGetInventoryResponse`"))),
1002            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::TapeDriveGetInventoryResponse`")))),
1003        }
1004    } else {
1005        let content = resp.text().await?;
1006        let entity: Option<TapeDriveGetInventoryError> = serde_json::from_str(&content).ok();
1007        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1008    }
1009}
1010
1011/// Read media label (optionally inventorize media)
1012pub async fn tape_drive_get_read_label(configuration: &configuration::Configuration, drive: &str, inventorize: Option<bool>) -> Result<models::TapeDriveGetReadLabelResponse, Error<TapeDriveGetReadLabelError>> {
1013    // add a prefix to parameters to efficiently prevent name collisions
1014    let p_path_drive = drive;
1015    let p_query_inventorize = inventorize;
1016
1017    let uri_str = format!("{}/tape/drive/{drive}/read-label", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
1018    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1019
1020    if let Some(ref param_value) = p_query_inventorize {
1021        req_builder = req_builder.query(&[("inventorize", &param_value.to_string())]);
1022    }
1023    if let Some(ref user_agent) = configuration.user_agent {
1024        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1025    }
1026    if let Some(ref apikey) = configuration.api_key {
1027        let key = apikey.key.clone();
1028        let value = match apikey.prefix {
1029            Some(ref prefix) => format!("{} {}", prefix, key),
1030            None => key,
1031        };
1032        req_builder = req_builder.header("Authorization", value);
1033    };
1034    if let Some(ref apikey) = configuration.api_key {
1035        let key = apikey.key.clone();
1036        let value = match apikey.prefix {
1037            Some(ref prefix) => format!("{} {}", prefix, key),
1038            None => key,
1039        };
1040        req_builder = req_builder.header("CSRFPreventionToken", value);
1041    };
1042
1043    let req = req_builder.build()?;
1044    let resp = configuration.client.execute(req).await?;
1045
1046    let status = resp.status();
1047    let content_type = resp
1048        .headers()
1049        .get("content-type")
1050        .and_then(|v| v.to_str().ok())
1051        .unwrap_or("application/octet-stream");
1052    let content_type = super::ContentType::from(content_type);
1053
1054    if !status.is_client_error() && !status.is_server_error() {
1055        let content = resp.text().await?;
1056        match content_type {
1057            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1058            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveGetReadLabelResponse`"))),
1059            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::TapeDriveGetReadLabelResponse`")))),
1060        }
1061    } else {
1062        let content = resp.text().await?;
1063        let entity: Option<TapeDriveGetReadLabelError> = serde_json::from_str(&content).ok();
1064        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1065    }
1066}
1067
1068/// Get drive/media status
1069pub async fn tape_drive_get_status(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveGetStatusResponse, Error<TapeDriveGetStatusError>> {
1070    // add a prefix to parameters to efficiently prevent name collisions
1071    let p_path_drive = drive;
1072
1073    let uri_str = format!("{}/tape/drive/{drive}/status", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
1074    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1075
1076    if let Some(ref user_agent) = configuration.user_agent {
1077        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1078    }
1079    if let Some(ref apikey) = configuration.api_key {
1080        let key = apikey.key.clone();
1081        let value = match apikey.prefix {
1082            Some(ref prefix) => format!("{} {}", prefix, key),
1083            None => key,
1084        };
1085        req_builder = req_builder.header("Authorization", value);
1086    };
1087    if let Some(ref apikey) = configuration.api_key {
1088        let key = apikey.key.clone();
1089        let value = match apikey.prefix {
1090            Some(ref prefix) => format!("{} {}", prefix, key),
1091            None => key,
1092        };
1093        req_builder = req_builder.header("CSRFPreventionToken", value);
1094    };
1095
1096    let req = req_builder.build()?;
1097    let resp = configuration.client.execute(req).await?;
1098
1099    let status = resp.status();
1100    let content_type = resp
1101        .headers()
1102        .get("content-type")
1103        .and_then(|v| v.to_str().ok())
1104        .unwrap_or("application/octet-stream");
1105    let content_type = super::ContentType::from(content_type);
1106
1107    if !status.is_client_error() && !status.is_server_error() {
1108        let content = resp.text().await?;
1109        match content_type {
1110            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1111            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveGetStatusResponse`"))),
1112            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::TapeDriveGetStatusResponse`")))),
1113        }
1114    } else {
1115        let content = resp.text().await?;
1116        let entity: Option<TapeDriveGetStatusError> = serde_json::from_str(&content).ok();
1117        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1118    }
1119}
1120
1121/// Directory index.
1122pub async fn tape_drive_get_tape_drive_by_drive(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveGetTapeDriveByDriveResponse, Error<TapeDriveGetTapeDriveByDriveError>> {
1123    // add a prefix to parameters to efficiently prevent name collisions
1124    let p_path_drive = drive;
1125
1126    let uri_str = format!("{}/tape/drive/{drive}", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
1127    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1128
1129    if let Some(ref user_agent) = configuration.user_agent {
1130        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1131    }
1132    if let Some(ref apikey) = configuration.api_key {
1133        let key = apikey.key.clone();
1134        let value = match apikey.prefix {
1135            Some(ref prefix) => format!("{} {}", prefix, key),
1136            None => key,
1137        };
1138        req_builder = req_builder.header("Authorization", value);
1139    };
1140    if let Some(ref apikey) = configuration.api_key {
1141        let key = apikey.key.clone();
1142        let value = match apikey.prefix {
1143            Some(ref prefix) => format!("{} {}", prefix, key),
1144            None => key,
1145        };
1146        req_builder = req_builder.header("CSRFPreventionToken", value);
1147    };
1148
1149    let req = req_builder.build()?;
1150    let resp = configuration.client.execute(req).await?;
1151
1152    let status = resp.status();
1153    let content_type = resp
1154        .headers()
1155        .get("content-type")
1156        .and_then(|v| v.to_str().ok())
1157        .unwrap_or("application/octet-stream");
1158    let content_type = super::ContentType::from(content_type);
1159
1160    if !status.is_client_error() && !status.is_server_error() {
1161        let content = resp.text().await?;
1162        match content_type {
1163            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1164            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveGetTapeDriveByDriveResponse`"))),
1165            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::TapeDriveGetTapeDriveByDriveResponse`")))),
1166        }
1167    } else {
1168        let content = resp.text().await?;
1169        let entity: Option<TapeDriveGetTapeDriveByDriveError> = serde_json::from_str(&content).ok();
1170        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1171    }
1172}
1173
1174/// Read Volume Statistics (SCSI log page 17h)
1175pub async fn tape_drive_get_volume_statistics(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveGetVolumeStatisticsResponse, Error<TapeDriveGetVolumeStatisticsError>> {
1176    // add a prefix to parameters to efficiently prevent name collisions
1177    let p_path_drive = drive;
1178
1179    let uri_str = format!("{}/tape/drive/{drive}/volume-statistics", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
1180    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1181
1182    if let Some(ref user_agent) = configuration.user_agent {
1183        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1184    }
1185    if let Some(ref apikey) = configuration.api_key {
1186        let key = apikey.key.clone();
1187        let value = match apikey.prefix {
1188            Some(ref prefix) => format!("{} {}", prefix, key),
1189            None => key,
1190        };
1191        req_builder = req_builder.header("Authorization", value);
1192    };
1193    if let Some(ref apikey) = configuration.api_key {
1194        let key = apikey.key.clone();
1195        let value = match apikey.prefix {
1196            Some(ref prefix) => format!("{} {}", prefix, key),
1197            None => key,
1198        };
1199        req_builder = req_builder.header("CSRFPreventionToken", value);
1200    };
1201
1202    let req = req_builder.build()?;
1203    let resp = configuration.client.execute(req).await?;
1204
1205    let status = resp.status();
1206    let content_type = resp
1207        .headers()
1208        .get("content-type")
1209        .and_then(|v| v.to_str().ok())
1210        .unwrap_or("application/octet-stream");
1211    let content_type = super::ContentType::from(content_type);
1212
1213    if !status.is_client_error() && !status.is_server_error() {
1214        let content = resp.text().await?;
1215        match content_type {
1216            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1217            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveGetVolumeStatisticsResponse`"))),
1218            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::TapeDriveGetVolumeStatisticsResponse`")))),
1219        }
1220    } else {
1221        let content = resp.text().await?;
1222        let entity: Option<TapeDriveGetVolumeStatisticsError> = serde_json::from_str(&content).ok();
1223        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1224    }
1225}
1226
1227/// Clean drive
1228pub async fn tape_drive_update_clean(configuration: &configuration::Configuration, drive: &str) -> Result<models::TapeDriveUpdateCleanResponse, Error<TapeDriveUpdateCleanError>> {
1229    // add a prefix to parameters to efficiently prevent name collisions
1230    let p_path_drive = drive;
1231
1232    let uri_str = format!("{}/tape/drive/{drive}/clean", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
1233    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
1234
1235    if let Some(ref user_agent) = configuration.user_agent {
1236        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1237    }
1238    if let Some(ref apikey) = configuration.api_key {
1239        let key = apikey.key.clone();
1240        let value = match apikey.prefix {
1241            Some(ref prefix) => format!("{} {}", prefix, key),
1242            None => key,
1243        };
1244        req_builder = req_builder.header("Authorization", value);
1245    };
1246    if let Some(ref apikey) = configuration.api_key {
1247        let key = apikey.key.clone();
1248        let value = match apikey.prefix {
1249            Some(ref prefix) => format!("{} {}", prefix, key),
1250            None => key,
1251        };
1252        req_builder = req_builder.header("CSRFPreventionToken", value);
1253    };
1254
1255    let req = req_builder.build()?;
1256    let resp = configuration.client.execute(req).await?;
1257
1258    let status = resp.status();
1259    let content_type = resp
1260        .headers()
1261        .get("content-type")
1262        .and_then(|v| v.to_str().ok())
1263        .unwrap_or("application/octet-stream");
1264    let content_type = super::ContentType::from(content_type);
1265
1266    if !status.is_client_error() && !status.is_server_error() {
1267        let content = resp.text().await?;
1268        match content_type {
1269            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1270            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveUpdateCleanResponse`"))),
1271            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::TapeDriveUpdateCleanResponse`")))),
1272        }
1273    } else {
1274        let content = resp.text().await?;
1275        let entity: Option<TapeDriveUpdateCleanError> = serde_json::from_str(&content).ok();
1276        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1277    }
1278}
1279
1280/// Export media with specified label
1281pub async fn tape_drive_update_export_media(configuration: &configuration::Configuration, drive: &str, tape_drive_update_export_media_request: models::TapeDriveUpdateExportMediaRequest) -> Result<models::TapeDriveUpdateExportMediaResponse, Error<TapeDriveUpdateExportMediaError>> {
1282    // add a prefix to parameters to efficiently prevent name collisions
1283    let p_path_drive = drive;
1284    let p_body_tape_drive_update_export_media_request = tape_drive_update_export_media_request;
1285
1286    let uri_str = format!("{}/tape/drive/{drive}/export-media", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
1287    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
1288
1289    if let Some(ref user_agent) = configuration.user_agent {
1290        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1291    }
1292    if let Some(ref apikey) = configuration.api_key {
1293        let key = apikey.key.clone();
1294        let value = match apikey.prefix {
1295            Some(ref prefix) => format!("{} {}", prefix, key),
1296            None => key,
1297        };
1298        req_builder = req_builder.header("Authorization", value);
1299    };
1300    if let Some(ref apikey) = configuration.api_key {
1301        let key = apikey.key.clone();
1302        let value = match apikey.prefix {
1303            Some(ref prefix) => format!("{} {}", prefix, key),
1304            None => key,
1305        };
1306        req_builder = req_builder.header("CSRFPreventionToken", value);
1307    };
1308    req_builder = req_builder.json(&p_body_tape_drive_update_export_media_request);
1309
1310    let req = req_builder.build()?;
1311    let resp = configuration.client.execute(req).await?;
1312
1313    let status = resp.status();
1314    let content_type = resp
1315        .headers()
1316        .get("content-type")
1317        .and_then(|v| v.to_str().ok())
1318        .unwrap_or("application/octet-stream");
1319    let content_type = super::ContentType::from(content_type);
1320
1321    if !status.is_client_error() && !status.is_server_error() {
1322        let content = resp.text().await?;
1323        match content_type {
1324            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1325            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveUpdateExportMediaResponse`"))),
1326            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::TapeDriveUpdateExportMediaResponse`")))),
1327        }
1328    } else {
1329        let content = resp.text().await?;
1330        let entity: Option<TapeDriveUpdateExportMediaError> = serde_json::from_str(&content).ok();
1331        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1332    }
1333}
1334
1335/// Update inventory  Note: Only useful for drives with associated changer device.  This method queries the changer to get a list of media labels. It then loads any unknown media into the drive, reads the label, and store the result to the media database.  If `catalog` is true, also tries to restore the catalog from tape.  Note: This updates the media online status.
1336pub async fn tape_drive_update_inventory(configuration: &configuration::Configuration, drive: &str, tape_drive_update_inventory_request: Option<models::TapeDriveUpdateInventoryRequest>) -> Result<models::TapeDriveUpdateInventoryResponse, Error<TapeDriveUpdateInventoryError>> {
1337    // add a prefix to parameters to efficiently prevent name collisions
1338    let p_path_drive = drive;
1339    let p_body_tape_drive_update_inventory_request = tape_drive_update_inventory_request;
1340
1341    let uri_str = format!("{}/tape/drive/{drive}/inventory", configuration.base_path, drive=crate::apis::urlencode(p_path_drive));
1342    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
1343
1344    if let Some(ref user_agent) = configuration.user_agent {
1345        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1346    }
1347    if let Some(ref apikey) = configuration.api_key {
1348        let key = apikey.key.clone();
1349        let value = match apikey.prefix {
1350            Some(ref prefix) => format!("{} {}", prefix, key),
1351            None => key,
1352        };
1353        req_builder = req_builder.header("Authorization", value);
1354    };
1355    if let Some(ref apikey) = configuration.api_key {
1356        let key = apikey.key.clone();
1357        let value = match apikey.prefix {
1358            Some(ref prefix) => format!("{} {}", prefix, key),
1359            None => key,
1360        };
1361        req_builder = req_builder.header("CSRFPreventionToken", value);
1362    };
1363    req_builder = req_builder.json(&p_body_tape_drive_update_inventory_request);
1364
1365    let req = req_builder.build()?;
1366    let resp = configuration.client.execute(req).await?;
1367
1368    let status = resp.status();
1369    let content_type = resp
1370        .headers()
1371        .get("content-type")
1372        .and_then(|v| v.to_str().ok())
1373        .unwrap_or("application/octet-stream");
1374    let content_type = super::ContentType::from(content_type);
1375
1376    if !status.is_client_error() && !status.is_server_error() {
1377        let content = resp.text().await?;
1378        match content_type {
1379            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1380            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TapeDriveUpdateInventoryResponse`"))),
1381            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::TapeDriveUpdateInventoryResponse`")))),
1382        }
1383    } else {
1384        let content = resp.text().await?;
1385        let entity: Option<TapeDriveUpdateInventoryError> = serde_json::from_str(&content).ok();
1386        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1387    }
1388}
1389
clientapi_pbs/apis/tape_drive_api.rs

clientapi_pbs/apis/
tape_drive_api.rs
