#![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<dyn azure_core::auth::TokenCredential>,
scopes: Vec<String>,
pipeline: azure_core::Pipeline,
}
#[derive(Clone)]
pub struct ClientBuilder {
credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
endpoint: Option<azure_core::Url>,
scopes: Option<Vec<String>>,
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<dyn azure_core::auth::TokenCredential>) -> 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<azure_core::Url>) -> 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<azure_core::RetryOptions>) -> Self {
self.options = self.options.retry(retry);
self
}
#[doc = "Set the transport options."]
#[must_use]
pub fn transport(mut self, transport: impl Into<azure_core::TransportOptions>) -> Self {
self.options = self.options.transport(transport);
self
}
#[doc = "Convert the builder into a `Client` instance."]
pub fn build(self) -> azure_core::Result<Client> {
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<azure_core::auth::Secret> {
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<azure_core::Response> {
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<dyn azure_core::auth::TokenCredential>) -> ClientBuilder {
ClientBuilder::new(credential)
}
#[doc = "Create a new `Client`."]
#[must_use]
pub fn new(
endpoint: impl Into<azure_core::Url>,
credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
scopes: Vec<String>,
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 disk_pool_zones_client(&self) -> disk_pool_zones::Client {
disk_pool_zones::Client(self.clone())
}
pub fn disk_pools_client(&self) -> disk_pools::Client {
disk_pools::Client(self.clone())
}
pub fn iscsi_targets_client(&self) -> iscsi_targets::Client {
iscsi_targets::Client(self.clone())
}
pub fn operations_client(&self) -> operations::Client {
operations::Client(self.clone())
}
pub fn resource_skus_client(&self) -> resource_skus::Client {
resource_skus::Client(self.clone())
}
}
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 = "Gets a list of StoragePool 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<models::StoragePoolOperationListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::StoragePoolOperationListResult = 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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 = "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<Response>> {
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<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!("{}/providers/Microsoft.StoragePool/operations", self.client.endpoint(),))?;
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, "2021-08-01");
}
Ok(url)
}
}
}
}
pub mod disk_pools {
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 list of Disk Pools in a subscription"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
pub fn list_by_subscription(&self, subscription_id: impl Into<String>) -> list_by_subscription::RequestBuilder {
list_by_subscription::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a list of DiskPools in a resource group."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
pub fn list_by_resource_group(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
) -> 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 = "Get a Disk pool."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
#[doc = "* `disk_pool_name`: The name of the Disk Pool."]
pub fn get(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
disk_pool_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
disk_pool_name: disk_pool_name.into(),
}
}
#[doc = "Create or Update Disk pool. This create or update operation can take 15 minutes to complete. This is expected service behavior."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
#[doc = "* `disk_pool_name`: The name of the Disk Pool."]
#[doc = "* `disk_pool_create_payload`: Request payload for Disk Pool create operation"]
pub fn create_or_update(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
disk_pool_name: impl Into<String>,
disk_pool_create_payload: impl Into<models::DiskPoolCreate>,
) -> create_or_update::RequestBuilder {
create_or_update::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
disk_pool_name: disk_pool_name.into(),
disk_pool_create_payload: disk_pool_create_payload.into(),
}
}
#[doc = "Update a Disk pool."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
#[doc = "* `disk_pool_name`: The name of the Disk Pool."]
#[doc = "* `disk_pool_update_payload`: Request payload for Disk Pool update operation."]
pub fn update(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
disk_pool_name: impl Into<String>,
disk_pool_update_payload: impl Into<models::DiskPoolUpdate>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
disk_pool_name: disk_pool_name.into(),
disk_pool_update_payload: disk_pool_update_payload.into(),
}
}
#[doc = "Delete a Disk pool; attached disks are not affected. This delete operation can take 10 minutes to complete. This is expected service behavior."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
#[doc = "* `disk_pool_name`: The name of the Disk Pool."]
pub fn delete(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
disk_pool_name: impl Into<String>,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
disk_pool_name: disk_pool_name.into(),
}
}
#[doc = "Gets the network endpoints of all outbound dependencies of a Disk Pool"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
#[doc = "* `disk_pool_name`: The name of the Disk Pool."]
pub fn list_outbound_network_dependencies_endpoints(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
disk_pool_name: impl Into<String>,
) -> list_outbound_network_dependencies_endpoints::RequestBuilder {
list_outbound_network_dependencies_endpoints::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
disk_pool_name: disk_pool_name.into(),
}
}
#[doc = "The operation to start a Disk Pool. This start operation can take 10 minutes to complete. This is expected service behavior."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
#[doc = "* `disk_pool_name`: The name of the Disk Pool."]
pub fn start(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
disk_pool_name: impl Into<String>,
) -> start::RequestBuilder {
start::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
disk_pool_name: disk_pool_name.into(),
}
}
#[doc = "Shuts down the Disk Pool and releases the compute resources. You are not billed for the compute resources that this Disk Pool uses. This operation can take 10 minutes to complete. This is expected service behavior."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
#[doc = "* `disk_pool_name`: The name of the Disk Pool."]
pub fn deallocate(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
disk_pool_name: impl Into<String>,
) -> deallocate::RequestBuilder {
deallocate::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
disk_pool_name: disk_pool_name.into(),
}
}
#[doc = "Upgrade replaces the underlying virtual machine hosts one at a time. This operation can take 10-15 minutes to complete. This is expected service behavior."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
#[doc = "* `disk_pool_name`: The name of the Disk Pool."]
pub fn upgrade(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
disk_pool_name: impl Into<String>,
) -> upgrade::RequestBuilder {
upgrade::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
disk_pool_name: disk_pool_name.into(),
}
}
}
pub mod list_by_subscription {
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<models::DiskPoolListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiskPoolListResult = 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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 {
pub fn into_stream(self) -> azure_core::Pageable<models::DiskPoolListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
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, "2021-08-01");
}
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<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.StoragePool/diskPools",
self.client.endpoint(),
&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, "2021-08-01");
}
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<models::DiskPoolListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiskPoolListResult = 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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 {
pub fn into_stream(self) -> azure_core::Pageable<models::DiskPoolListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
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, "2021-08-01");
}
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<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools",
self.client.endpoint(),
&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, "2021-08-01");
}
Ok(url)
}
}
}
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<models::DiskPool> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiskPool = 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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) disk_pool_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<Response>> {
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<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools/{}",
self.client.endpoint(),
&self.subscription_id,
&self.resource_group_name,
&self.disk_pool_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, "2021-08-01");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::DiskPool>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::DiskPool>>;
#[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<models::DiskPool> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiskPool = 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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) disk_pool_name: String,
pub(crate) disk_pool_create_payload: models::DiskPoolCreate,
}
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<Response>> {
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.disk_pool_create_payload)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools/{}",
self.client.endpoint(),
&self.subscription_id,
&self.resource_group_name,
&self.disk_pool_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, "2021-08-01");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::DiskPool>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::DiskPool>>;
#[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 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<models::DiskPool> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiskPool = 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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) disk_pool_name: String,
pub(crate) disk_pool_update_payload: models::DiskPoolUpdate,
}
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<Response>> {
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.disk_pool_update_payload)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools/{}",
self.client.endpoint(),
&self.subscription_id,
&self.resource_group_name,
&self.disk_pool_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, "2021-08-01");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::DiskPool>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::DiskPool>>;
#[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 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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) disk_pool_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<Response>> {
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<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools/{}",
self.client.endpoint(),
&self.subscription_id,
&self.resource_group_name,
&self.disk_pool_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, "2021-08-01");
}
Ok(url)
}
}
}
pub mod list_outbound_network_dependencies_endpoints {
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<models::OutboundEnvironmentEndpointList> {
let bytes = self.0.into_body().collect().await?;
let body: models::OutboundEnvironmentEndpointList = 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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) disk_pool_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::OutboundEnvironmentEndpointList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
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, "2021-08-01");
}
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<azure_core::Url> {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools/{}/outboundNetworkDependenciesEndpoints" , self . client . endpoint () , & self . subscription_id , & self . resource_group_name , & self . disk_pool_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, "2021-08-01");
}
Ok(url)
}
}
}
pub mod start {
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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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) disk_pool_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<Response>> {
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<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools/{}/start",
self.client.endpoint(),
&self.subscription_id,
&self.resource_group_name,
&self.disk_pool_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, "2021-08-01");
}
Ok(url)
}
}
}
pub mod deallocate {
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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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) disk_pool_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<Response>> {
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<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools/{}/deallocate",
self.client.endpoint(),
&self.subscription_id,
&self.resource_group_name,
&self.disk_pool_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, "2021-08-01");
}
Ok(url)
}
}
}
pub mod upgrade {
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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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) disk_pool_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<Response>> {
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<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools/{}/upgrade",
self.client.endpoint(),
&self.subscription_id,
&self.resource_group_name,
&self.disk_pool_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, "2021-08-01");
}
Ok(url)
}
}
}
}
pub mod disk_pool_zones {
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 available Disk Pool Skus in an Azure location."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `location`: The location of the resource."]
pub fn list(&self, subscription_id: impl Into<String>, location: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
location: location.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<models::DiskPoolZoneListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiskPoolZoneListResult = 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DiskPoolZoneListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
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, "2021-08-01");
}
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<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.StoragePool/locations/{}/diskPoolZones",
self.client.endpoint(),
&self.subscription_id,
&self.location
))?;
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, "2021-08-01");
}
Ok(url)
}
}
}
}
pub mod resource_skus {
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 available StoragePool resources and skus in an Azure location."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `location`: The location of the resource."]
pub fn list(&self, subscription_id: impl Into<String>, location: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
location: location.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<models::ResourceSkuListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::ResourceSkuListResult = 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ResourceSkuListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
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, "2021-08-01");
}
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<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.StoragePool/locations/{}/skus",
self.client.endpoint(),
&self.subscription_id,
&self.location
))?;
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, "2021-08-01");
}
Ok(url)
}
}
}
}
pub mod iscsi_targets {
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 iSCSI Targets in a Disk pool."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
#[doc = "* `disk_pool_name`: The name of the Disk Pool."]
pub fn list_by_disk_pool(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
disk_pool_name: impl Into<String>,
) -> list_by_disk_pool::RequestBuilder {
list_by_disk_pool::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
disk_pool_name: disk_pool_name.into(),
}
}
#[doc = "Get an iSCSI Target."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
#[doc = "* `disk_pool_name`: The name of the Disk Pool."]
#[doc = "* `iscsi_target_name`: The name of the iSCSI Target."]
pub fn get(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
disk_pool_name: impl Into<String>,
iscsi_target_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
disk_pool_name: disk_pool_name.into(),
iscsi_target_name: iscsi_target_name.into(),
}
}
#[doc = "Create or Update an iSCSI Target."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
#[doc = "* `disk_pool_name`: The name of the Disk Pool."]
#[doc = "* `iscsi_target_name`: The name of the iSCSI Target."]
#[doc = "* `iscsi_target_create_payload`: Request payload for iSCSI Target create operation."]
pub fn create_or_update(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
disk_pool_name: impl Into<String>,
iscsi_target_name: impl Into<String>,
iscsi_target_create_payload: impl Into<models::IscsiTargetCreate>,
) -> create_or_update::RequestBuilder {
create_or_update::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
disk_pool_name: disk_pool_name.into(),
iscsi_target_name: iscsi_target_name.into(),
iscsi_target_create_payload: iscsi_target_create_payload.into(),
}
}
#[doc = "Update an iSCSI Target."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
#[doc = "* `disk_pool_name`: The name of the Disk Pool."]
#[doc = "* `iscsi_target_name`: The name of the iSCSI Target."]
#[doc = "* `iscsi_target_update_payload`: Request payload for iSCSI Target update operation."]
pub fn update(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
disk_pool_name: impl Into<String>,
iscsi_target_name: impl Into<String>,
iscsi_target_update_payload: impl Into<models::IscsiTargetUpdate>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
disk_pool_name: disk_pool_name.into(),
iscsi_target_name: iscsi_target_name.into(),
iscsi_target_update_payload: iscsi_target_update_payload.into(),
}
}
#[doc = "Delete an iSCSI Target."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: The ID of the target subscription."]
#[doc = "* `resource_group_name`: The name of the resource group. The name is case insensitive."]
#[doc = "* `disk_pool_name`: The name of the Disk Pool."]
#[doc = "* `iscsi_target_name`: The name of the iSCSI Target."]
pub fn delete(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
disk_pool_name: impl Into<String>,
iscsi_target_name: impl Into<String>,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
disk_pool_name: disk_pool_name.into(),
iscsi_target_name: iscsi_target_name.into(),
}
}
}
pub mod list_by_disk_pool {
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<models::IscsiTargetList> {
let bytes = self.0.into_body().collect().await?;
let body: models::IscsiTargetList = 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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) disk_pool_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::IscsiTargetList, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
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, "2021-08-01");
}
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<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools/{}/iscsiTargets",
self.client.endpoint(),
&self.subscription_id,
&self.resource_group_name,
&self.disk_pool_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, "2021-08-01");
}
Ok(url)
}
}
}
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<models::IscsiTarget> {
let bytes = self.0.into_body().collect().await?;
let body: models::IscsiTarget = 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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) disk_pool_name: String,
pub(crate) iscsi_target_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<Response>> {
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<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools/{}/iscsiTargets/{}",
self.client.endpoint(),
&self.subscription_id,
&self.resource_group_name,
&self.disk_pool_name,
&self.iscsi_target_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, "2021-08-01");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::IscsiTarget>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::IscsiTarget>>;
#[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<models::IscsiTarget> {
let bytes = self.0.into_body().collect().await?;
let body: models::IscsiTarget = 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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) disk_pool_name: String,
pub(crate) iscsi_target_name: String,
pub(crate) iscsi_target_create_payload: models::IscsiTargetCreate,
}
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<Response>> {
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.iscsi_target_create_payload)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools/{}/iscsiTargets/{}",
self.client.endpoint(),
&self.subscription_id,
&self.resource_group_name,
&self.disk_pool_name,
&self.iscsi_target_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, "2021-08-01");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::IscsiTarget>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::IscsiTarget>>;
#[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 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<models::IscsiTarget> {
let bytes = self.0.into_body().collect().await?;
let body: models::IscsiTarget = 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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) disk_pool_name: String,
pub(crate) iscsi_target_name: String,
pub(crate) iscsi_target_update_payload: models::IscsiTargetUpdate,
}
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<Response>> {
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.iscsi_target_update_payload)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
fn url(&self) -> azure_core::Result<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools/{}/iscsiTargets/{}",
self.client.endpoint(),
&self.subscription_id,
&self.resource_group_name,
&self.disk_pool_name,
&self.iscsi_target_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, "2021-08-01");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::IscsiTarget>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::IscsiTarget>>;
#[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 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<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> 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) disk_pool_name: String,
pub(crate) iscsi_target_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<Response>> {
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<azure_core::Url> {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.StoragePool/diskPools/{}/iscsiTargets/{}",
self.client.endpoint(),
&self.subscription_id,
&self.resource_group_name,
&self.disk_pool_name,
&self.iscsi_target_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, "2021-08-01");
}
Ok(url)
}
}
}
}