Skip to main content

unitycatalog_client/codegen/volumes/
client.rs

1// @generated — do not edit by hand.
2#![allow(unused_imports)]
3use crate::Result;
4#[cfg(not(target_arch = "wasm32"))]
5use ::olai_http::CloudClient as Transport;
6#[cfg(target_arch = "wasm32")]
7use ::olai_http_wasm::WasmClient as Transport;
8use unitycatalog_common::models::volumes::v1::*;
9use url::Url;
10/// HTTP client for service operations
11#[derive(Clone)]
12pub struct VolumeServiceClient {
13    pub(crate) client: Transport,
14    pub(crate) base_url: Url,
15}
16impl VolumeServiceClient {
17    /// Create a new client instance
18    pub fn new(client: Transport, mut base_url: Url) -> Self {
19        if !base_url.path().ends_with('/') {
20            base_url.set_path(&format!("{}/", base_url.path()));
21        }
22        Self { client, base_url }
23    }
24    /// Lists volumes.
25    pub async fn list_volumes(&self, request: &ListVolumesRequest) -> Result<ListVolumesResponse> {
26        let mut url = self.base_url.join("volumes")?;
27        url.query_pairs_mut()
28            .append_pair("catalog_name", &request.catalog_name);
29        url.query_pairs_mut()
30            .append_pair("schema_name", &request.schema_name);
31        if let Some(ref value) = request.max_results {
32            url.query_pairs_mut()
33                .append_pair("max_results", &value.to_string());
34        }
35        if let Some(ref value) = request.page_token {
36            url.query_pairs_mut()
37                .append_pair("page_token", &value.to_string());
38        }
39        if let Some(ref value) = request.include_browse {
40            url.query_pairs_mut()
41                .append_pair("include_browse", &value.to_string());
42        }
43        let response = self.client.get(url).send().await?;
44        if !response.status().is_success() {
45            return Err(crate::error::parse_error_response(response).await);
46        }
47        let result = response.bytes().await?;
48        Ok(serde_json::from_slice(&result)?)
49    }
50    pub async fn create_volume(&self, request: &CreateVolumeRequest) -> Result<Volume> {
51        let url = self.base_url.join("volumes")?;
52        let response = self.client.post(url).json(request).send().await?;
53        if !response.status().is_success() {
54            return Err(crate::error::parse_error_response(response).await);
55        }
56        let result = response.bytes().await?;
57        Ok(serde_json::from_slice(&result)?)
58    }
59    pub async fn get_volume(&self, request: &GetVolumeRequest) -> Result<Volume> {
60        let formatted_path = format!("volumes/{}", request.name);
61        let mut url = self.base_url.join(&formatted_path)?;
62        if let Some(ref value) = request.include_browse {
63            url.query_pairs_mut()
64                .append_pair("include_browse", &value.to_string());
65        }
66        let response = self.client.get(url).send().await?;
67        if !response.status().is_success() {
68            return Err(crate::error::parse_error_response(response).await);
69        }
70        let result = response.bytes().await?;
71        Ok(serde_json::from_slice(&result)?)
72    }
73    pub async fn update_volume(&self, request: &UpdateVolumeRequest) -> Result<Volume> {
74        let formatted_path = format!("volumes/{}", request.name);
75        let url = self.base_url.join(&formatted_path)?;
76        let response = self.client.patch(url).json(request).send().await?;
77        if !response.status().is_success() {
78            return Err(crate::error::parse_error_response(response).await);
79        }
80        let result = response.bytes().await?;
81        Ok(serde_json::from_slice(&result)?)
82    }
83    pub async fn delete_volume(&self, request: &DeleteVolumeRequest) -> Result<()> {
84        let formatted_path = format!("volumes/{}", request.name);
85        let url = self.base_url.join(&formatted_path)?;
86        let response = self.client.delete(url).send().await?;
87        if !response.status().is_success() {
88            return Err(crate::error::parse_error_response(response).await);
89        }
90        Ok(())
91    }
92}