#![allow(unused_mut)] #![allow(unused_variables)] #![allow(unused_imports)] #![allow(clippy::redundant_clone)] pub mod models; #[derive(Clone)] pub struct Client { endpoint: azure_core::Url, credential: std::sync::Arc, scopes: Vec, pipeline: azure_core::Pipeline, } #[derive(Clone)] pub struct ClientBuilder { credential: std::sync::Arc, endpoint: Option, scopes: Option>, options: azure_core::ClientOptions, } pub use azure_core::resource_manager_endpoint::AZURE_PUBLIC_CLOUD as DEFAULT_ENDPOINT; impl ClientBuilder { #[doc = "Create a new instance of `ClientBuilder`."] #[must_use] pub fn new(credential: std::sync::Arc) -> Self { Self { credential, endpoint: None, scopes: None, options: azure_core::ClientOptions::default(), } } #[doc = "Set the endpoint."] #[must_use] pub fn endpoint(mut self, endpoint: impl Into) -> Self { self.endpoint = Some(endpoint.into()); self } #[doc = "Set the scopes."] #[must_use] pub fn scopes(mut self, scopes: &[&str]) -> Self { self.scopes = Some(scopes.iter().map(|scope| (*scope).to_owned()).collect()); self } #[doc = "Set the retry options."] #[must_use] pub fn retry(mut self, retry: impl Into) -> Self { self.options = self.options.retry(retry); self } #[doc = "Set the transport options."] #[must_use] pub fn transport(mut self, transport: impl Into) -> Self { self.options = self.options.transport(transport); self } #[doc = "Convert the builder into a `Client` instance."] pub fn build(self) -> azure_core::Result { let endpoint = self.endpoint.unwrap_or_else(|| DEFAULT_ENDPOINT.to_owned()); let scopes = if let Some(scopes) = self.scopes { scopes } else { vec![endpoint.join(azure_core::auth::DEFAULT_SCOPE_SUFFIX)?.to_string()] }; Ok(Client::new(endpoint, self.credential, scopes, self.options)) } } impl Client { pub(crate) async fn bearer_token(&self) -> azure_core::Result { let credential = self.token_credential(); let response = credential.get_token(&self.scopes()).await?; Ok(response.token) } pub(crate) fn endpoint(&self) -> &azure_core::Url { &self.endpoint } pub(crate) fn token_credential(&self) -> &dyn azure_core::auth::TokenCredential { self.credential.as_ref() } pub(crate) fn scopes(&self) -> Vec<&str> { self.scopes.iter().map(String::as_str).collect() } pub(crate) async fn send(&self, request: &mut azure_core::Request) -> azure_core::Result { let context = azure_core::Context::default(); self.pipeline.send(&context, request).await } #[doc = "Create a new `ClientBuilder`."] #[must_use] pub fn builder(credential: std::sync::Arc) -> ClientBuilder { ClientBuilder::new(credential) } #[doc = "Create a new `Client`."] #[must_use] pub fn new( endpoint: impl Into, credential: std::sync::Arc, scopes: Vec, options: azure_core::ClientOptions, ) -> Self { let endpoint = endpoint.into(); let pipeline = azure_core::Pipeline::new( option_env!("CARGO_PKG_NAME"), option_env!("CARGO_PKG_VERSION"), options, Vec::new(), Vec::new(), ); Self { endpoint, credential, scopes, pipeline, } } pub fn check_name_availability_client(&self) -> check_name_availability::Client { check_name_availability::Client(self.clone()) } pub fn configurations_client(&self) -> configurations::Client { configurations::Client(self.clone()) } pub fn databases_client(&self) -> databases::Client { databases::Client(self.clone()) } pub fn firewall_rules_client(&self) -> firewall_rules::Client { firewall_rules::Client(self.clone()) } pub fn location_based_performance_tier_client(&self) -> location_based_performance_tier::Client { location_based_performance_tier::Client(self.clone()) } pub fn log_files_client(&self) -> log_files::Client { log_files::Client(self.clone()) } pub fn operations_client(&self) -> operations::Client { operations::Client(self.clone()) } pub fn recoverable_servers_client(&self) -> recoverable_servers::Client { recoverable_servers::Client(self.clone()) } pub fn replicas_client(&self) -> replicas::Client { replicas::Client(self.clone()) } pub fn server_based_performance_tier_client(&self) -> server_based_performance_tier::Client { server_based_performance_tier::Client(self.clone()) } pub fn server_parameters_client(&self) -> server_parameters::Client { server_parameters::Client(self.clone()) } pub fn server_security_alert_policies_client(&self) -> server_security_alert_policies::Client { server_security_alert_policies::Client(self.clone()) } pub fn servers_client(&self) -> servers::Client { servers::Client(self.clone()) } pub fn virtual_network_rules_client(&self) -> virtual_network_rules::Client { virtual_network_rules::Client(self.clone()) } } pub mod servers { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "Gets information about a server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] pub fn get( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, ) -> get::RequestBuilder { get::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), } } #[doc = "Creates a new server or updates an existing server. The update action will overwrite the existing server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `parameters`: The required parameters for creating or updating a server."] pub fn create( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, parameters: impl Into, ) -> create::RequestBuilder { create::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), parameters: parameters.into(), } } #[doc = "Updates an existing server. The request body can contain one to many of the properties present in the normal server definition."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `parameters`: The required parameters for updating a server."] pub fn update( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, parameters: impl Into, ) -> update::RequestBuilder { update::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), parameters: parameters.into(), } } #[doc = "Deletes a server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] pub fn delete( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, ) -> delete::RequestBuilder { delete::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), } } #[doc = "List all the servers in a given resource group."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] pub fn list_by_resource_group( &self, subscription_id: impl Into, resource_group_name: impl Into, ) -> list_by_resource_group::RequestBuilder { list_by_resource_group::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), } } #[doc = "List all the servers in a given subscription."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] pub fn list(&self, subscription_id: impl Into) -> list::RequestBuilder { list::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), } } #[doc = "Restarts a server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] pub fn restart( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, ) -> restart::RequestBuilder { restart::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), } } } pub mod get { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::Server = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that sends the request and returns the parsed response body."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { self.send().await?.into_body().await }) } } } pub mod create { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::Server = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" This `RequestBuilder` implements a Long Running Operation"] #[doc = r" (LRO)."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the `RequestBuilder` into a future"] #[doc = r" executes the request and polls the service until the"] #[doc = r" operation completes."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use"] #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"] #[doc = r" [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) parameters: models::ServerForCreate, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Put); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); req.insert_header("content-type", "application/json"); let req_body = azure_core::to_json(&this.parameters)?; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that polls the long running operation and checks for the state via `properties.provisioningState` in the response body."] #[doc = ""] #[doc = "To only submit the request but not monitor the status of the operation until completion, use `send()` instead."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { use azure_core::{ error::{Error, ErrorKind}, lro::{body_content::get_provisioning_state, get_retry_after, LroStatus}, sleep::sleep, }; use std::time::Duration; loop { let this = self.clone(); let response = this.send().await?; let retry_after = get_retry_after(response.as_raw_response().headers()); let status = response.as_raw_response().status(); let body = response.into_body().await?; let provisioning_state = get_provisioning_state(status, &body)?; log::trace!("current provisioning_state: {provisioning_state:?}"); match provisioning_state { LroStatus::Succeeded => return Ok(body), LroStatus::Failed => return Err(Error::message(ErrorKind::Other, "Long running operation failed".to_string())), LroStatus::Canceled => { return Err(Error::message(ErrorKind::Other, "Long running operation canceled".to_string())) } _ => { sleep(retry_after).await; } } } }) } } } pub mod update { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::Server = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" This `RequestBuilder` implements a Long Running Operation"] #[doc = r" (LRO)."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the `RequestBuilder` into a future"] #[doc = r" executes the request and polls the service until the"] #[doc = r" operation completes."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use"] #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"] #[doc = r" [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) parameters: models::ServerUpdateParameters, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Patch); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); req.insert_header("content-type", "application/json"); let req_body = azure_core::to_json(&this.parameters)?; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that polls the long running operation and checks for the state via `properties.provisioningState` in the response body."] #[doc = ""] #[doc = "To only submit the request but not monitor the status of the operation until completion, use `send()` instead."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { use azure_core::{ error::{Error, ErrorKind}, lro::{body_content::get_provisioning_state, get_retry_after, LroStatus}, sleep::sleep, }; use std::time::Duration; loop { let this = self.clone(); let response = this.send().await?; let retry_after = get_retry_after(response.as_raw_response().headers()); let status = response.as_raw_response().status(); let body = response.into_body().await?; let provisioning_state = get_provisioning_state(status, &body)?; log::trace!("current provisioning_state: {provisioning_state:?}"); match provisioning_state { LroStatus::Succeeded => return Ok(body), LroStatus::Failed => return Err(Error::message(ErrorKind::Other, "Long running operation failed".to_string())), LroStatus::Canceled => { return Err(Error::message(ErrorKind::Other, "Long running operation canceled".to_string())) } _ => { sleep(retry_after).await; } } } }) } } } pub mod delete { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" This `RequestBuilder` implements a Long Running Operation"] #[doc = r" (LRO)."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the `RequestBuilder` into a future"] #[doc = r" executes the request and polls the service until the"] #[doc = r" operation completes."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use"] #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"] #[doc = r" [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Delete); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } pub mod list_by_resource_group { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::ServerListResult = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, } impl RequestBuilder { #[doc = "Only the first response will be fetched as the continuation token is not part of the response schema"] #[doc = ""] #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers", &self.subscription_id, &self.resource_group_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } pub mod list { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::ServerListResult = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, } impl RequestBuilder { #[doc = "Only the first response will be fetched as the continuation token is not part of the response schema"] #[doc = ""] #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/providers/Microsoft.DBforMariaDB/servers", &self.subscription_id )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } pub mod restart { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" This `RequestBuilder` implements a Long Running Operation"] #[doc = r" (LRO)."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the `RequestBuilder` into a future"] #[doc = r" executes the request and polls the service until the"] #[doc = r" operation completes."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use"] #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"] #[doc = r" [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Post); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.insert_header(azure_core::headers::CONTENT_LENGTH, "0"); req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/restart", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } } pub mod replicas { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "List all the replicas for a given server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] pub fn list_by_server( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, ) -> list_by_server::RequestBuilder { list_by_server::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), } } } pub mod list_by_server { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::ServerListResult = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, } impl RequestBuilder { #[doc = "Only the first response will be fetched as the continuation token is not part of the response schema"] #[doc = ""] #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/replicas", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } } pub mod firewall_rules { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "Gets information about a server firewall rule."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `firewall_rule_name`: The name of the server firewall rule."] pub fn get( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, firewall_rule_name: impl Into, ) -> get::RequestBuilder { get::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), firewall_rule_name: firewall_rule_name.into(), } } #[doc = "Creates a new firewall rule or updates an existing firewall rule."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `firewall_rule_name`: The name of the server firewall rule."] #[doc = "* `parameters`: The required parameters for creating or updating a firewall rule."] pub fn create_or_update( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, firewall_rule_name: impl Into, parameters: impl Into, ) -> create_or_update::RequestBuilder { create_or_update::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), firewall_rule_name: firewall_rule_name.into(), parameters: parameters.into(), } } #[doc = "Deletes a server firewall rule."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `firewall_rule_name`: The name of the server firewall rule."] pub fn delete( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, firewall_rule_name: impl Into, ) -> delete::RequestBuilder { delete::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), firewall_rule_name: firewall_rule_name.into(), } } #[doc = "List all the firewall rules in a given server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] pub fn list_by_server( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, ) -> list_by_server::RequestBuilder { list_by_server::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), } } } pub mod get { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::FirewallRule = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) firewall_rule_name: String, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/firewallRules/{}", &self.subscription_id, &self.resource_group_name, &self.server_name, &self.firewall_rule_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that sends the request and returns the parsed response body."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { self.send().await?.into_body().await }) } } } pub mod create_or_update { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::FirewallRule = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" This `RequestBuilder` implements a Long Running Operation"] #[doc = r" (LRO)."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the `RequestBuilder` into a future"] #[doc = r" executes the request and polls the service until the"] #[doc = r" operation completes."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use"] #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"] #[doc = r" [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) firewall_rule_name: String, pub(crate) parameters: models::FirewallRule, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Put); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); req.insert_header("content-type", "application/json"); let req_body = azure_core::to_json(&this.parameters)?; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/firewallRules/{}", &self.subscription_id, &self.resource_group_name, &self.server_name, &self.firewall_rule_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that polls the long running operation and checks for the state via `properties.provisioningState` in the response body."] #[doc = ""] #[doc = "To only submit the request but not monitor the status of the operation until completion, use `send()` instead."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { use azure_core::{ error::{Error, ErrorKind}, lro::{body_content::get_provisioning_state, get_retry_after, LroStatus}, sleep::sleep, }; use std::time::Duration; loop { let this = self.clone(); let response = this.send().await?; let retry_after = get_retry_after(response.as_raw_response().headers()); let status = response.as_raw_response().status(); let body = response.into_body().await?; let provisioning_state = get_provisioning_state(status, &body)?; log::trace!("current provisioning_state: {provisioning_state:?}"); match provisioning_state { LroStatus::Succeeded => return Ok(body), LroStatus::Failed => return Err(Error::message(ErrorKind::Other, "Long running operation failed".to_string())), LroStatus::Canceled => { return Err(Error::message(ErrorKind::Other, "Long running operation canceled".to_string())) } _ => { sleep(retry_after).await; } } } }) } } } pub mod delete { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" This `RequestBuilder` implements a Long Running Operation"] #[doc = r" (LRO)."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the `RequestBuilder` into a future"] #[doc = r" executes the request and polls the service until the"] #[doc = r" operation completes."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use"] #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"] #[doc = r" [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) firewall_rule_name: String, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Delete); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/firewallRules/{}", &self.subscription_id, &self.resource_group_name, &self.server_name, &self.firewall_rule_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } pub mod list_by_server { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::FirewallRuleListResult = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, } impl RequestBuilder { #[doc = "Only the first response will be fetched as the continuation token is not part of the response schema"] #[doc = ""] #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/firewallRules", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } } pub mod virtual_network_rules { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "Gets a virtual network rule."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `virtual_network_rule_name`: The name of the virtual network rule."] pub fn get( &self, resource_group_name: impl Into, server_name: impl Into, subscription_id: impl Into, virtual_network_rule_name: impl Into, ) -> get::RequestBuilder { get::RequestBuilder { client: self.0.clone(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), subscription_id: subscription_id.into(), virtual_network_rule_name: virtual_network_rule_name.into(), } } #[doc = "Creates or updates an existing virtual network rule."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `virtual_network_rule_name`: The name of the virtual network rule."] #[doc = "* `parameters`: The requested virtual Network Rule Resource state."] pub fn create_or_update( &self, resource_group_name: impl Into, server_name: impl Into, subscription_id: impl Into, virtual_network_rule_name: impl Into, parameters: impl Into, ) -> create_or_update::RequestBuilder { create_or_update::RequestBuilder { client: self.0.clone(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), subscription_id: subscription_id.into(), virtual_network_rule_name: virtual_network_rule_name.into(), parameters: parameters.into(), } } #[doc = "Deletes the virtual network rule with the given name."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `virtual_network_rule_name`: The name of the virtual network rule."] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] pub fn delete( &self, resource_group_name: impl Into, server_name: impl Into, virtual_network_rule_name: impl Into, subscription_id: impl Into, ) -> delete::RequestBuilder { delete::RequestBuilder { client: self.0.clone(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), virtual_network_rule_name: virtual_network_rule_name.into(), subscription_id: subscription_id.into(), } } #[doc = "Gets a list of virtual network rules in a server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] pub fn list_by_server( &self, resource_group_name: impl Into, server_name: impl Into, subscription_id: impl Into, ) -> list_by_server::RequestBuilder { list_by_server::RequestBuilder { client: self.0.clone(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), subscription_id: subscription_id.into(), } } } pub mod get { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::VirtualNetworkRule = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) subscription_id: String, pub(crate) virtual_network_rule_name: String, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/virtualNetworkRules/{}", &self.subscription_id, &self.resource_group_name, &self.server_name, &self.virtual_network_rule_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that sends the request and returns the parsed response body."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { self.send().await?.into_body().await }) } } } pub mod create_or_update { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::VirtualNetworkRule = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" This `RequestBuilder` implements a Long Running Operation"] #[doc = r" (LRO)."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the `RequestBuilder` into a future"] #[doc = r" executes the request and polls the service until the"] #[doc = r" operation completes."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use"] #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"] #[doc = r" [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) subscription_id: String, pub(crate) virtual_network_rule_name: String, pub(crate) parameters: models::VirtualNetworkRule, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Put); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); req.insert_header("content-type", "application/json"); let req_body = azure_core::to_json(&this.parameters)?; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/virtualNetworkRules/{}", &self.subscription_id, &self.resource_group_name, &self.server_name, &self.virtual_network_rule_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that polls the long running operation and checks for the state via `properties.provisioningState` in the response body."] #[doc = ""] #[doc = "To only submit the request but not monitor the status of the operation until completion, use `send()` instead."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { use azure_core::{ error::{Error, ErrorKind}, lro::{body_content::get_provisioning_state, get_retry_after, LroStatus}, sleep::sleep, }; use std::time::Duration; loop { let this = self.clone(); let response = this.send().await?; let retry_after = get_retry_after(response.as_raw_response().headers()); let status = response.as_raw_response().status(); let body = response.into_body().await?; let provisioning_state = get_provisioning_state(status, &body)?; log::trace!("current provisioning_state: {provisioning_state:?}"); match provisioning_state { LroStatus::Succeeded => return Ok(body), LroStatus::Failed => return Err(Error::message(ErrorKind::Other, "Long running operation failed".to_string())), LroStatus::Canceled => { return Err(Error::message(ErrorKind::Other, "Long running operation canceled".to_string())) } _ => { sleep(retry_after).await; } } } }) } } } pub mod delete { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" This `RequestBuilder` implements a Long Running Operation"] #[doc = r" (LRO)."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the `RequestBuilder` into a future"] #[doc = r" executes the request and polls the service until the"] #[doc = r" operation completes."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use"] #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"] #[doc = r" [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) virtual_network_rule_name: String, pub(crate) subscription_id: String, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Delete); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/virtualNetworkRules/{}", &self.subscription_id, &self.resource_group_name, &self.server_name, &self.virtual_network_rule_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } pub mod list_by_server { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::VirtualNetworkRuleListResult = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) subscription_id: String, } impl RequestBuilder { pub fn into_stream(self) -> azure_core::Pageable { let make_request = move |continuation: Option| { let this = self.clone(); async move { let mut url = this.url()?; let rsp = match continuation { Some(value) => { url.set_path(""); url = url.join(&value)?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let has_api_version_already = req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { req.url_mut() .query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); this.client.send(&mut req).await? } None => { let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); this.client.send(&mut req).await? } }; let rsp = match rsp.status() { azure_core::StatusCode::Ok => Ok(Response(rsp)), status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse { status: status_code, error_code: None, })), }; rsp?.into_body().await } }; azure_core::Pageable::new(make_request) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/virtualNetworkRules", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } } pub mod databases { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "Gets information about a database."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `database_name`: The name of the database."] pub fn get( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, database_name: impl Into, ) -> get::RequestBuilder { get::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), database_name: database_name.into(), } } #[doc = "Creates a new database or updates an existing database."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `database_name`: The name of the database."] #[doc = "* `parameters`: The required parameters for creating or updating a database."] pub fn create_or_update( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, database_name: impl Into, parameters: impl Into, ) -> create_or_update::RequestBuilder { create_or_update::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), database_name: database_name.into(), parameters: parameters.into(), } } #[doc = "Deletes a database."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `database_name`: The name of the database."] pub fn delete( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, database_name: impl Into, ) -> delete::RequestBuilder { delete::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), database_name: database_name.into(), } } #[doc = "List all the databases in a given server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] pub fn list_by_server( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, ) -> list_by_server::RequestBuilder { list_by_server::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), } } } pub mod get { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::Database = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) database_name: String, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/databases/{}", &self.subscription_id, &self.resource_group_name, &self.server_name, &self.database_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that sends the request and returns the parsed response body."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { self.send().await?.into_body().await }) } } } pub mod create_or_update { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::Database = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" This `RequestBuilder` implements a Long Running Operation"] #[doc = r" (LRO)."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the `RequestBuilder` into a future"] #[doc = r" executes the request and polls the service until the"] #[doc = r" operation completes."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use"] #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"] #[doc = r" [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) database_name: String, pub(crate) parameters: models::Database, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Put); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); req.insert_header("content-type", "application/json"); let req_body = azure_core::to_json(&this.parameters)?; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/databases/{}", &self.subscription_id, &self.resource_group_name, &self.server_name, &self.database_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that polls the long running operation and checks for the state via `properties.provisioningState` in the response body."] #[doc = ""] #[doc = "To only submit the request but not monitor the status of the operation until completion, use `send()` instead."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { use azure_core::{ error::{Error, ErrorKind}, lro::{body_content::get_provisioning_state, get_retry_after, LroStatus}, sleep::sleep, }; use std::time::Duration; loop { let this = self.clone(); let response = this.send().await?; let retry_after = get_retry_after(response.as_raw_response().headers()); let status = response.as_raw_response().status(); let body = response.into_body().await?; let provisioning_state = get_provisioning_state(status, &body)?; log::trace!("current provisioning_state: {provisioning_state:?}"); match provisioning_state { LroStatus::Succeeded => return Ok(body), LroStatus::Failed => return Err(Error::message(ErrorKind::Other, "Long running operation failed".to_string())), LroStatus::Canceled => { return Err(Error::message(ErrorKind::Other, "Long running operation canceled".to_string())) } _ => { sleep(retry_after).await; } } } }) } } } pub mod delete { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" This `RequestBuilder` implements a Long Running Operation"] #[doc = r" (LRO)."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the `RequestBuilder` into a future"] #[doc = r" executes the request and polls the service until the"] #[doc = r" operation completes."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use"] #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"] #[doc = r" [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) database_name: String, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Delete); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/databases/{}", &self.subscription_id, &self.resource_group_name, &self.server_name, &self.database_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } pub mod list_by_server { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::DatabaseListResult = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, } impl RequestBuilder { #[doc = "Only the first response will be fetched as the continuation token is not part of the response schema"] #[doc = ""] #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/databases", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } } pub mod configurations { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "Gets information about a configuration of server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `configuration_name`: The name of the server configuration."] pub fn get( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, configuration_name: impl Into, ) -> get::RequestBuilder { get::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), configuration_name: configuration_name.into(), } } #[doc = "Updates a configuration of a server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `configuration_name`: The name of the server configuration."] #[doc = "* `parameters`: The required parameters for updating a server configuration."] pub fn create_or_update( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, configuration_name: impl Into, parameters: impl Into, ) -> create_or_update::RequestBuilder { create_or_update::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), configuration_name: configuration_name.into(), parameters: parameters.into(), } } #[doc = "List all the configurations in a given server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] pub fn list_by_server( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, ) -> list_by_server::RequestBuilder { list_by_server::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), } } } pub mod get { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::Configuration = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) configuration_name: String, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/configurations/{}", &self.subscription_id, &self.resource_group_name, &self.server_name, &self.configuration_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that sends the request and returns the parsed response body."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { self.send().await?.into_body().await }) } } } pub mod create_or_update { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::Configuration = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" This `RequestBuilder` implements a Long Running Operation"] #[doc = r" (LRO)."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the `RequestBuilder` into a future"] #[doc = r" executes the request and polls the service until the"] #[doc = r" operation completes."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use"] #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"] #[doc = r" [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) configuration_name: String, pub(crate) parameters: models::Configuration, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Put); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); req.insert_header("content-type", "application/json"); let req_body = azure_core::to_json(&this.parameters)?; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/configurations/{}", &self.subscription_id, &self.resource_group_name, &self.server_name, &self.configuration_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that polls the long running operation and checks for the state via `properties.provisioningState` in the response body."] #[doc = ""] #[doc = "To only submit the request but not monitor the status of the operation until completion, use `send()` instead."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { use azure_core::{ error::{Error, ErrorKind}, lro::{body_content::get_provisioning_state, get_retry_after, LroStatus}, sleep::sleep, }; use std::time::Duration; loop { let this = self.clone(); let response = this.send().await?; let retry_after = get_retry_after(response.as_raw_response().headers()); let status = response.as_raw_response().status(); let body = response.into_body().await?; let provisioning_state = get_provisioning_state(status, &body)?; log::trace!("current provisioning_state: {provisioning_state:?}"); match provisioning_state { LroStatus::Succeeded => return Ok(body), LroStatus::Failed => return Err(Error::message(ErrorKind::Other, "Long running operation failed".to_string())), LroStatus::Canceled => { return Err(Error::message(ErrorKind::Other, "Long running operation canceled".to_string())) } _ => { sleep(retry_after).await; } } } }) } } } pub mod list_by_server { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::ConfigurationListResult = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, } impl RequestBuilder { #[doc = "Only the first response will be fetched as the continuation token is not part of the response schema"] #[doc = ""] #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/configurations", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } } pub mod server_parameters { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "Update a list of configurations in a given server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `value`: The parameters for updating a list of server configuration."] pub fn list_update_configurations( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, value: impl Into, ) -> list_update_configurations::RequestBuilder { list_update_configurations::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), value: value.into(), } } } pub mod list_update_configurations { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::ConfigurationListResult = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" This `RequestBuilder` implements a Long Running Operation"] #[doc = r" (LRO)."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the `RequestBuilder` into a future"] #[doc = r" executes the request and polls the service until the"] #[doc = r" operation completes."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use"] #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"] #[doc = r" [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) value: models::ConfigurationListResult, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Post); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); req.insert_header("content-type", "application/json"); let req_body = azure_core::to_json(&this.value)?; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/updateConfigurations", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that polls the long running operation, returning once the operation completes."] #[doc = ""] #[doc = "To only submit the request but not monitor the status of the operation until completion, use `send()` instead."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { use azure_core::{ error::{Error, ErrorKind}, lro::{ get_retry_after, location::{get_location, get_provisioning_state, FinalState}, LroStatus, }, sleep::sleep, }; use std::time::Duration; let this = self.clone(); let response = this.send().await?; let headers = response.as_raw_response().headers(); let location = get_location(headers, FinalState::AzureAsyncOperation)?; if let Some(url) = location { loop { let mut req = azure_core::Request::new(url.clone(), azure_core::Method::Get); let bearer_token = self.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let response = self.client.send(&mut req).await?; let headers = response.headers(); let retry_after = get_retry_after(headers); let bytes = response.into_body().collect().await?; let provisioning_state = get_provisioning_state(&bytes).ok_or_else(|| { Error::message( ErrorKind::Other, "Long running operation failed (missing provisioning state)".to_string(), ) })?; log::trace!("current provisioning_state: {provisioning_state:?}"); match provisioning_state { LroStatus::Succeeded => { let mut req = azure_core::Request::new(self.url()?, azure_core::Method::Get); let bearer_token = self.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let response = self.client.send(&mut req).await?; return Response(response).into_body().await; } LroStatus::Failed => { return Err(Error::message(ErrorKind::Other, "Long running operation failed".to_string())) } LroStatus::Canceled => { return Err(Error::message(ErrorKind::Other, "Long running operation canceled".to_string())) } _ => { sleep(retry_after).await; } } } } else { response.into_body().await } }) } } } } pub mod log_files { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "List all the log files in a given server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] pub fn list_by_server( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, ) -> list_by_server::RequestBuilder { list_by_server::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), } } } pub mod list_by_server { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::LogFileListResult = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, } impl RequestBuilder { #[doc = "Only the first response will be fetched as the continuation token is not part of the response schema"] #[doc = ""] #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/logFiles", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } } pub mod recoverable_servers { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "Gets a recoverable MariaDB Server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] pub fn get( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, ) -> get::RequestBuilder { get::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), } } } pub mod get { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::RecoverableServerResource = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/recoverableServers", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that sends the request and returns the parsed response body."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { self.send().await?.into_body().await }) } } } } pub mod server_based_performance_tier { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "List all the performance tiers for a MariaDB server."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] pub fn list( &self, subscription_id: impl Into, resource_group_name: impl Into, server_name: impl Into, ) -> list::RequestBuilder { list::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), } } } pub mod list { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::PerformanceTierListResult = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) resource_group_name: String, pub(crate) server_name: String, } impl RequestBuilder { #[doc = "Only the first response will be fetched as the continuation token is not part of the response schema"] #[doc = ""] #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/performanceTiers", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } } pub mod location_based_performance_tier { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "List all the performance tiers at specified location in a given subscription."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `location_name`: The name of the location."] pub fn list(&self, subscription_id: impl Into, location_name: impl Into) -> list::RequestBuilder { list::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), location_name: location_name.into(), } } } pub mod list { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::PerformanceTierListResult = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) location_name: String, } impl RequestBuilder { #[doc = "Only the first response will be fetched as the continuation token is not part of the response schema"] #[doc = ""] #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/providers/Microsoft.DBforMariaDB/locations/{}/performanceTiers", &self.subscription_id, &self.location_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } } pub mod check_name_availability { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "Check the availability of name for resource"] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] #[doc = "* `name_availability_request`: The required parameters for checking if resource name is available."] pub fn execute( &self, subscription_id: impl Into, name_availability_request: impl Into, ) -> execute::RequestBuilder { execute::RequestBuilder { client: self.0.clone(), subscription_id: subscription_id.into(), name_availability_request: name_availability_request.into(), } } } pub mod execute { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::NameAvailability = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) subscription_id: String, pub(crate) name_availability_request: models::NameAvailabilityRequest, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Post); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); req.insert_header("content-type", "application/json"); let req_body = azure_core::to_json(&this.name_availability_request)?; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/providers/Microsoft.DBforMariaDB/checkNameAvailability", &self.subscription_id )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that sends the request and returns the parsed response body."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { self.send().await?.into_body().await }) } } } } pub mod server_security_alert_policies { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "Get a server's security alert policy."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `security_alert_policy_name`: The name of the security alert policy."] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] pub fn get( &self, resource_group_name: impl Into, server_name: impl Into, security_alert_policy_name: impl Into, subscription_id: impl Into, ) -> get::RequestBuilder { get::RequestBuilder { client: self.0.clone(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), security_alert_policy_name: security_alert_policy_name.into(), subscription_id: subscription_id.into(), } } #[doc = "Creates or updates a threat detection policy."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `security_alert_policy_name`: The name of the threat detection policy."] #[doc = "* `parameters`: The server security alert policy."] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] pub fn create_or_update( &self, resource_group_name: impl Into, server_name: impl Into, security_alert_policy_name: impl Into, parameters: impl Into, subscription_id: impl Into, ) -> create_or_update::RequestBuilder { create_or_update::RequestBuilder { client: self.0.clone(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), security_alert_policy_name: security_alert_policy_name.into(), parameters: parameters.into(), subscription_id: subscription_id.into(), } } #[doc = "Get the server's threat detection policies."] #[doc = ""] #[doc = "Arguments:"] #[doc = "* `resource_group_name`: The name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal."] #[doc = "* `server_name`: The name of the server."] #[doc = "* `subscription_id`: The subscription ID that identifies an Azure subscription."] pub fn list_by_server( &self, resource_group_name: impl Into, server_name: impl Into, subscription_id: impl Into, ) -> list_by_server::RequestBuilder { list_by_server::RequestBuilder { client: self.0.clone(), resource_group_name: resource_group_name.into(), server_name: server_name.into(), subscription_id: subscription_id.into(), } } } pub mod get { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::ServerSecurityAlertPolicy = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) security_alert_policy_name: String, pub(crate) subscription_id: String, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/securityAlertPolicies/{}", &self.subscription_id, &self.resource_group_name, &self.server_name, &self.security_alert_policy_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that sends the request and returns the parsed response body."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { self.send().await?.into_body().await }) } } } pub mod create_or_update { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::ServerSecurityAlertPolicy = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" This `RequestBuilder` implements a Long Running Operation"] #[doc = r" (LRO)."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the `RequestBuilder` into a future"] #[doc = r" executes the request and polls the service until the"] #[doc = r" operation completes."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use"] #[doc = r" [`RequestBuilder::send()`], which will return a lower-level"] #[doc = r" [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) security_alert_policy_name: String, pub(crate) parameters: models::ServerSecurityAlertPolicy, pub(crate) subscription_id: String, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Put); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); req.insert_header("content-type", "application/json"); let req_body = azure_core::to_json(&this.parameters)?; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/securityAlertPolicies/{}", &self.subscription_id, &self.resource_group_name, &self.server_name, &self.security_alert_policy_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that polls the long running operation and checks for the state via `properties.provisioningState` in the response body."] #[doc = ""] #[doc = "To only submit the request but not monitor the status of the operation until completion, use `send()` instead."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { use azure_core::{ error::{Error, ErrorKind}, lro::{body_content::get_provisioning_state, get_retry_after, LroStatus}, sleep::sleep, }; use std::time::Duration; loop { let this = self.clone(); let response = this.send().await?; let retry_after = get_retry_after(response.as_raw_response().headers()); let status = response.as_raw_response().status(); let body = response.into_body().await?; let provisioning_state = get_provisioning_state(status, &body)?; log::trace!("current provisioning_state: {provisioning_state:?}"); match provisioning_state { LroStatus::Succeeded => return Ok(body), LroStatus::Failed => return Err(Error::message(ErrorKind::Other, "Long running operation failed".to_string())), LroStatus::Canceled => { return Err(Error::message(ErrorKind::Other, "Long running operation canceled".to_string())) } _ => { sleep(retry_after).await; } } } }) } } } pub mod list_by_server { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::ServerSecurityAlertPolicyListResult = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, pub(crate) resource_group_name: String, pub(crate) server_name: String, pub(crate) subscription_id: String, } impl RequestBuilder { pub fn into_stream(self) -> azure_core::Pageable { let make_request = move |continuation: Option| { let this = self.clone(); async move { let mut url = this.url()?; let rsp = match continuation { Some(value) => { url.set_path(""); url = url.join(&value)?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let has_api_version_already = req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { req.url_mut() .query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); this.client.send(&mut req).await? } None => { let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); this.client.send(&mut req).await? } }; let rsp = match rsp.status() { azure_core::StatusCode::Ok => Ok(Response(rsp)), status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse { status: status_code, error_code: None, })), }; rsp?.into_body().await } }; azure_core::Pageable::new(make_request) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path(&format!( "/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DBforMariaDB/servers/{}/securityAlertPolicies", &self.subscription_id, &self.resource_group_name, &self.server_name )); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } } } pub mod operations { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; pub struct Client(pub(crate) super::Client); impl Client { #[doc = "Lists all of the available REST API operations."] pub fn list(&self) -> list::RequestBuilder { list::RequestBuilder { client: self.0.clone() } } } pub mod list { use super::models; #[cfg(not(target_arch = "wasm32"))] use futures::future::BoxFuture; #[cfg(target_arch = "wasm32")] use futures::future::LocalBoxFuture as BoxFuture; #[derive(Debug)] pub struct Response(azure_core::Response); impl Response { pub async fn into_body(self) -> azure_core::Result { let bytes = self.0.into_body().collect().await?; let body: models::OperationListResult = serde_json::from_slice(&bytes)?; Ok(body) } pub fn into_raw_response(self) -> azure_core::Response { self.0 } pub fn as_raw_response(&self) -> &azure_core::Response { &self.0 } } impl From for azure_core::Response { fn from(rsp: Response) -> Self { rsp.into_raw_response() } } impl AsRef for Response { fn as_ref(&self) -> &azure_core::Response { self.as_raw_response() } } #[derive(Clone)] #[doc = r" `RequestBuilder` provides a mechanism for setting optional parameters on a request."] #[doc = r""] #[doc = r" Each `RequestBuilder` parameter method call returns `Self`, so setting of multiple"] #[doc = r" parameters can be chained."] #[doc = r""] #[doc = r" To finalize and submit the request, invoke `.await`, which"] #[doc = r" which will convert the [`RequestBuilder`] into a future"] #[doc = r" executes the request and returns a `Result` with the parsed"] #[doc = r" response."] #[doc = r""] #[doc = r" In order to execute the request without polling the service"] #[doc = r" until the operation completes, use `.send().await` instead."] #[doc = r""] #[doc = r" If you need lower-level access to the raw response details"] #[doc = r" (e.g. to inspect response headers or raw body data) then you"] #[doc = r" can finalize the request using the"] #[doc = r" [`RequestBuilder::send()`] method which returns a future"] #[doc = r" that resolves to a lower-level [`Response`] value."] pub struct RequestBuilder { pub(crate) client: super::super::Client, } impl RequestBuilder { #[doc = "Returns a future that sends the request and returns a [`Response`] object that provides low-level access to full response details."] #[doc = ""] #[doc = "You should typically use `.await` (which implicitly calls `IntoFuture::into_future()`) to finalize and send requests rather than `send()`."] #[doc = "However, this function can provide more flexibility when required."] pub fn send(self) -> BoxFuture<'static, azure_core::Result> { Box::pin({ let this = self.clone(); async move { let url = this.url()?; let mut req = azure_core::Request::new(url, azure_core::Method::Get); let bearer_token = this.client.bearer_token().await?; req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret())); let req_body = azure_core::EMPTY_BODY; req.set_body(req_body); Ok(Response(this.client.send(&mut req).await?)) } }) } fn url(&self) -> azure_core::Result { let mut url = self.client.endpoint().clone(); url.set_path("/providers/Microsoft.DBforMariaDB/operations"); let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION); if !has_api_version_already { url.query_pairs_mut() .append_pair(azure_core::query_param::API_VERSION, "2018-06-01-preview"); } Ok(url) } } impl std::future::IntoFuture for RequestBuilder { type Output = azure_core::Result; type IntoFuture = BoxFuture<'static, azure_core::Result>; #[doc = "Returns a future that sends the request and returns the parsed response body."] #[doc = ""] #[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."] #[doc = ""] #[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."] fn into_future(self) -> Self::IntoFuture { Box::pin(async move { self.send().await?.into_body().await }) } } } }