#![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 check_name_availability_client(&self) -> check_name_availability::Client {
check_name_availability::Client(self.clone())
}
pub fn diagnostics_client(&self) -> diagnostics::Client {
diagnostics::Client(self.clone())
}
pub fn discovery_solution_client(&self) -> discovery_solution::Client {
discovery_solution::Client(self.clone())
}
pub fn operations_client(&self) -> operations::Client {
operations::Client(self.clone())
}
pub fn solution_client(&self) -> solution::Client {
solution::Client(self.clone())
}
pub fn troubleshooters_client(&self) -> troubleshooters::Client {
troubleshooters::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 = "Returns list of 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::OperationListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::OperationListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<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 {
pub fn into_stream(self) -> azure_core::Pageable<models::OperationListResult, 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, "2023-09-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let bearer_token = this.client.bearer_token().await?;
req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
fn url(&self) -> azure_core::Result<azure_core::Url> {
let mut url = self.client.endpoint().clone();
url.set_path("/providers/Microsoft.Help/operations");
let has_api_version_already = url.query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
url.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2023-09-01-preview");
}
Ok(url)
}
}
}
}
pub mod check_name_availability {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "This API is used to check the uniqueness of a resource name used for a diagnostic, troubleshooter or solutions"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `scope`: scope = resourceUri of affected resource.<br/> For example: /subscriptions/0d0fcd2e-c4fd-4349-8497-200edb3923c6/resourcegroups/myresourceGroup/providers/Microsoft.KeyVault/vaults/test-keyvault-non-read "]
pub fn post(&self, scope: impl Into<String>) -> post::RequestBuilder {
post::RequestBuilder {
client: self.0.clone(),
scope: scope.into(),
check_name_availability_request: None,
}
}
}
pub mod post {
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::CheckNameAvailabilityResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::CheckNameAvailabilityResponse = 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) scope: String,
pub(crate) check_name_availability_request: Option<models::CheckNameAvailabilityRequest>,
}
impl RequestBuilder {
#[doc = "The required parameters for availability check."]
pub fn check_name_availability_request(
mut self,
check_name_availability_request: impl Into<models::CheckNameAvailabilityRequest>,
) -> Self {
self.check_name_availability_request = Some(check_name_availability_request.into());
self
}
#[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 = if let Some(check_name_availability_request) = &this.check_name_availability_request {
req.insert_header("content-type", "application/json");
azure_core::to_json(check_name_availability_request)?
} else {
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 = self.client.endpoint().clone();
url.set_path(&format!("/{}/providers/Microsoft.Help/checkNameAvailability", &self.scope));
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, "2023-09-01-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::CheckNameAvailabilityResponse>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::CheckNameAvailabilityResponse>>;
#[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 diagnostics {
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 the diagnostics using the 'diagnosticsResourceName' you chose while creating the diagnostic."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `scope`: scope = resourceUri of affected resource.<br/> For example: /subscriptions/0d0fcd2e-c4fd-4349-8497-200edb3923c6/resourcegroups/myresourceGroup/providers/Microsoft.KeyVault/vaults/test-keyvault-non-read "]
#[doc = "* `diagnostics_resource_name`: Unique resource name for insight resources"]
pub fn get(&self, scope: impl Into<String>, diagnostics_resource_name: impl Into<String>) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
scope: scope.into(),
diagnostics_resource_name: diagnostics_resource_name.into(),
}
}
#[doc = "Creates a diagnostic for the specific resource using solutionId and requiredInputs* from discovery solutions. <br/>Diagnostics are powerful solutions that access product resources or other relevant data and provide the root cause of the issue and the steps to address the issue.<br/><br/> <b>Note: </b> ‘requiredInputs’ from Discovery solutions response must be passed via ‘additionalParameters’ as an input to Diagnostics API."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `scope`: scope = resourceUri of affected resource.<br/> For example: /subscriptions/0d0fcd2e-c4fd-4349-8497-200edb3923c6/resourcegroups/myresourceGroup/providers/Microsoft.KeyVault/vaults/test-keyvault-non-read "]
#[doc = "* `diagnostics_resource_name`: Unique resource name for insight resources"]
pub fn create(&self, scope: impl Into<String>, diagnostics_resource_name: impl Into<String>) -> create::RequestBuilder {
create::RequestBuilder {
client: self.0.clone(),
scope: scope.into(),
diagnostics_resource_name: diagnostics_resource_name.into(),
diagnostic_resource_request: None,
}
}
}
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::DiagnosticResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticResource = 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) scope: String,
pub(crate) diagnostics_resource_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 = self.client.endpoint().clone();
url.set_path(&format!(
"/{}/providers/Microsoft.Help/diagnostics/{}",
&self.scope, &self.diagnostics_resource_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, "2023-09-01-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::DiagnosticResource>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::DiagnosticResource>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DiagnosticResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticResource = 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) scope: String,
pub(crate) diagnostics_resource_name: String,
pub(crate) diagnostic_resource_request: Option<models::DiagnosticResource>,
}
impl RequestBuilder {
#[doc = "The required request body for this insightResource invocation."]
pub fn diagnostic_resource_request(mut self, diagnostic_resource_request: impl Into<models::DiagnosticResource>) -> Self {
self.diagnostic_resource_request = Some(diagnostic_resource_request.into());
self
}
#[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()));
let req_body = if let Some(diagnostic_resource_request) = &this.diagnostic_resource_request {
req.insert_header("content-type", "application/json");
azure_core::to_json(diagnostic_resource_request)?
} else {
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 = self.client.endpoint().clone();
url.set_path(&format!(
"/{}/providers/Microsoft.Help/diagnostics/{}",
&self.scope, &self.diagnostics_resource_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, "2023-09-01-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::DiagnosticResource>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::DiagnosticResource>>;
#[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 discovery_solution {
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 the relevant Azure diagnostics and solutions using [problemClassification API](https://learn.microsoft.com/rest/api/support/problem-classifications/list?tabs=HTTP)) AND resourceUri or resourceType.<br/> Discovery Solutions is the initial entry point within Help API, which identifies relevant Azure diagnostics and solutions. <br/><br/> Required Input : problemClassificationId (Use the [problemClassification API](https://learn.microsoft.com/rest/api/support/problem-classifications/list?tabs=HTTP)) <br/>Optional input: resourceUri OR resource Type <br/><br/> <b>Note: </b> ‘requiredInputs’ from Discovery solutions response must be passed via ‘additionalParameters’ as an input to Diagnostics and Solutions API."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `scope`: scope = resourceUri of affected resource.<br/> For example: /subscriptions/0d0fcd2e-c4fd-4349-8497-200edb3923c6/resourcegroups/myresourceGroup/providers/Microsoft.KeyVault/vaults/test-keyvault-non-read "]
pub fn list(&self, scope: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
scope: scope.into(),
filter: None,
skiptoken: None,
}
}
}
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::DiscoveryResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiscoveryResponse = 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) scope: String,
pub(crate) filter: Option<String>,
pub(crate) skiptoken: Option<String>,
}
impl RequestBuilder {
#[doc = "'ProblemClassificationId' is a mandatory filter to get solutions ids. It also supports optional 'ResourceType' and 'SolutionType' filters. The [$filter](https://learn.microsoft.com/en-us/odata/webapi/first-odata-api#filter) supports only 'and', 'or' and 'eq' operators. Example: $filter=ProblemClassificationId eq '1ddda5b4-cf6c-4d4f-91ad-bc38ab0e811e'"]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "Skiptoken is only used if a previous operation returned a partial result."]
pub fn skiptoken(mut self, skiptoken: impl Into<String>) -> Self {
self.skiptoken = Some(skiptoken.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::DiscoveryResponse, 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, "2023-09-01-preview");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let bearer_token = this.client.bearer_token().await?;
req.insert_header(azure_core::headers::AUTHORIZATION, format!("Bearer {}", bearer_token.secret()));
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(skiptoken) = &this.skiptoken {
req.url_mut().query_pairs_mut().append_pair("$skiptoken", skiptoken);
}
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 = self.client.endpoint().clone();
url.set_path(&format!("/{}/providers/Microsoft.Help/discoverySolutions", &self.scope));
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, "2023-09-01-preview");
}
Ok(url)
}
}
}
}
pub mod solution {
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 the solution using the applicable solutionResourceName while creating the solution."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `scope`: scope = resourceUri of affected resource.<br/> For example: /subscriptions/0d0fcd2e-c4fd-4349-8497-200edb3923c6/resourcegroups/myresourceGroup/providers/Microsoft.KeyVault/vaults/test-keyvault-non-read "]
#[doc = "* `solution_resource_name`: Solution resource Name."]
pub fn get(&self, scope: impl Into<String>, solution_resource_name: impl Into<String>) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
scope: scope.into(),
solution_resource_name: solution_resource_name.into(),
}
}
#[doc = "Creates a solution for the specific Azure resource or subscription using the inputs ‘solutionId and requiredInputs’ from discovery solutions. <br/> Azure solutions comprise a comprehensive library of self-help resources that have been thoughtfully curated by Azure engineers to aid customers in resolving typical troubleshooting issues. These solutions encompass (1.) dynamic and context-aware diagnostics, guided troubleshooting wizards, and data visualizations, (2.) rich instructional video tutorials and illustrative diagrams and images, and (3.) thoughtfully assembled textual troubleshooting instructions. All these components are seamlessly converged into unified solutions tailored to address a specific support problem area. Each solution type may require one or more ‘requiredParameters’ that are required to execute the individual solution component. In the absence of the ‘requiredParameters’ it is likely that some of the solutions might fail execution, and you might see an empty response. <br/><br/> <b>Note:</b> <br/>1. ‘requiredInputs’ from Discovery solutions response must be passed via ‘parameters’ in the request body of Solutions API. <br/>2. ‘requiredParameters’ from the Solutions response is the same as ‘ additionalParameters’ in the request for diagnostics <br/>3. ‘requiredParameters’ from the Solutions response is the same as ‘properties.parameters’ in the request for Troubleshooters"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `scope`: scope = resourceUri of affected resource.<br/> For example: /subscriptions/0d0fcd2e-c4fd-4349-8497-200edb3923c6/resourcegroups/myresourceGroup/providers/Microsoft.KeyVault/vaults/test-keyvault-non-read "]
#[doc = "* `solution_resource_name`: Solution resource Name."]
pub fn create(&self, scope: impl Into<String>, solution_resource_name: impl Into<String>) -> create::RequestBuilder {
create::RequestBuilder {
client: self.0.clone(),
scope: scope.into(),
solution_resource_name: solution_resource_name.into(),
solution_request_body: None,
}
}
#[doc = "Update the requiredInputs or additional information needed to execute the solution "]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `scope`: scope = resourceUri of affected resource.<br/> For example: /subscriptions/0d0fcd2e-c4fd-4349-8497-200edb3923c6/resourcegroups/myresourceGroup/providers/Microsoft.KeyVault/vaults/test-keyvault-non-read "]
#[doc = "* `solution_resource_name`: Solution resource Name."]
pub fn update(&self, scope: impl Into<String>, solution_resource_name: impl Into<String>) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
scope: scope.into(),
solution_resource_name: solution_resource_name.into(),
solution_patch_request_body: None,
}
}
}
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::SolutionResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::SolutionResource = 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) scope: String,
pub(crate) solution_resource_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 = self.client.endpoint().clone();
url.set_path(&format!(
"/{}/providers/Microsoft.Help/solutions/{}",
&self.scope, &self.solution_resource_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, "2023-09-01-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::SolutionResource>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::SolutionResource>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SolutionResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::SolutionResource = 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) scope: String,
pub(crate) solution_resource_name: String,
pub(crate) solution_request_body: Option<models::SolutionResource>,
}
impl RequestBuilder {
#[doc = "The required request body for this solution resource creation."]
pub fn solution_request_body(mut self, solution_request_body: impl Into<models::SolutionResource>) -> Self {
self.solution_request_body = Some(solution_request_body.into());
self
}
#[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()));
let req_body = if let Some(solution_request_body) = &this.solution_request_body {
req.insert_header("content-type", "application/json");
azure_core::to_json(solution_request_body)?
} else {
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 = self.client.endpoint().clone();
url.set_path(&format!(
"/{}/providers/Microsoft.Help/solutions/{}",
&self.scope, &self.solution_resource_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, "2023-09-01-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::SolutionResource>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::SolutionResource>>;
#[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::SolutionResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::SolutionResource = 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
}
pub fn headers(&self) -> Headers {
Headers(self.0.headers())
}
}
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()
}
}
pub struct Headers<'a>(&'a azure_core::headers::Headers);
impl<'a> Headers<'a> {
pub fn location(&self) -> azure_core::Result<&str> {
self.0.get_str(&azure_core::headers::HeaderName::from_static("location"))
}
}
#[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) scope: String,
pub(crate) solution_resource_name: String,
pub(crate) solution_patch_request_body: Option<models::SolutionPatchRequestBody>,
}
impl RequestBuilder {
#[doc = "The required request body for updating a solution resource."]
pub fn solution_patch_request_body(mut self, solution_patch_request_body: impl Into<models::SolutionPatchRequestBody>) -> Self {
self.solution_patch_request_body = Some(solution_patch_request_body.into());
self
}
#[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()));
let req_body = if let Some(solution_patch_request_body) = &this.solution_patch_request_body {
req.insert_header("content-type", "application/json");
azure_core::to_json(solution_patch_request_body)?
} else {
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 = self.client.endpoint().clone();
url.set_path(&format!(
"/{}/providers/Microsoft.Help/solutions/{}",
&self.scope, &self.solution_resource_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, "2023-09-01-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::SolutionResource>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::SolutionResource>>;
#[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 troubleshooters {
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 troubleshooter instance result which includes the step status/result of the troubleshooter resource name that is being executed.<br/> Get API is used to retrieve the result of a Troubleshooter instance, which includes the status and result of each step in the Troubleshooter workflow. This API requires the Troubleshooter resource name that was created using the Create API."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `scope`: scope = resourceUri of affected resource.<br/> For example: /subscriptions/0d0fcd2e-c4fd-4349-8497-200edb3923c6/resourcegroups/myresourceGroup/providers/Microsoft.KeyVault/vaults/test-keyvault-non-read "]
#[doc = "* `troubleshooter_name`: Troubleshooter resource Name."]
pub fn get(&self, scope: impl Into<String>, troubleshooter_name: impl Into<String>) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
scope: scope.into(),
troubleshooter_name: troubleshooter_name.into(),
}
}
#[doc = "Creates the specific troubleshooter action under a resource or subscription using the ‘solutionId’ and ‘properties.parameters’ as the trigger. <br/> Azure Troubleshooters help with hard to classify issues, reducing the gap between customer observed problems and solutions by guiding the user effortlessly through the troubleshooting process. Each Troubleshooter flow represents a problem area within Azure and has a complex tree-like structure that addresses many root causes. These flows are prepared with the help of Subject Matter experts and customer support engineers by carefully considering previous support requests raised by customers. Troubleshooters terminate at a well curated solution based off of resource backend signals and customer manual selections."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `scope`: scope = resourceUri of affected resource.<br/> For example: /subscriptions/0d0fcd2e-c4fd-4349-8497-200edb3923c6/resourcegroups/myresourceGroup/providers/Microsoft.KeyVault/vaults/test-keyvault-non-read "]
#[doc = "* `troubleshooter_name`: Troubleshooter resource Name."]
pub fn create(&self, scope: impl Into<String>, troubleshooter_name: impl Into<String>) -> create::RequestBuilder {
create::RequestBuilder {
client: self.0.clone(),
scope: scope.into(),
troubleshooter_name: troubleshooter_name.into(),
create_troubleshooter_request_body: None,
}
}
#[doc = "Uses ‘stepId’ and ‘responses’ as the trigger to continue the troubleshooting steps for the respective troubleshooter resource name. <br/>Continue API is used to provide inputs that are required for the specific troubleshooter to progress into the next step in the process. This API is used after the Troubleshooter has been created using the Create API."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `scope`: scope = resourceUri of affected resource.<br/> For example: /subscriptions/0d0fcd2e-c4fd-4349-8497-200edb3923c6/resourcegroups/myresourceGroup/providers/Microsoft.KeyVault/vaults/test-keyvault-non-read "]
#[doc = "* `troubleshooter_name`: Troubleshooter resource Name."]
pub fn continue_(&self, scope: impl Into<String>, troubleshooter_name: impl Into<String>) -> continue_::RequestBuilder {
continue_::RequestBuilder {
client: self.0.clone(),
scope: scope.into(),
troubleshooter_name: troubleshooter_name.into(),
continue_request_body: None,
}
}
#[doc = "Ends the troubleshooter action"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `scope`: scope = resourceUri of affected resource.<br/> For example: /subscriptions/0d0fcd2e-c4fd-4349-8497-200edb3923c6/resourcegroups/myresourceGroup/providers/Microsoft.KeyVault/vaults/test-keyvault-non-read "]
#[doc = "* `troubleshooter_name`: Troubleshooter resource Name."]
pub fn end(&self, scope: impl Into<String>, troubleshooter_name: impl Into<String>) -> end::RequestBuilder {
end::RequestBuilder {
client: self.0.clone(),
scope: scope.into(),
troubleshooter_name: troubleshooter_name.into(),
}
}
#[doc = "Restarts the troubleshooter API using applicable troubleshooter resource name as the input.<br/> It returns new resource name which should be used in subsequent request. The old resource name is obsolete after this API is invoked."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `scope`: scope = resourceUri of affected resource.<br/> For example: /subscriptions/0d0fcd2e-c4fd-4349-8497-200edb3923c6/resourcegroups/myresourceGroup/providers/Microsoft.KeyVault/vaults/test-keyvault-non-read "]
#[doc = "* `troubleshooter_name`: Troubleshooter resource Name."]
pub fn restart(&self, scope: impl Into<String>, troubleshooter_name: impl Into<String>) -> restart::RequestBuilder {
restart::RequestBuilder {
client: self.0.clone(),
scope: scope.into(),
troubleshooter_name: troubleshooter_name.into(),
}
}
}
pub mod get {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TroubleshooterResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::TroubleshooterResource = 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) scope: String,
pub(crate) troubleshooter_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 = self.client.endpoint().clone();
url.set_path(&format!(
"/{}/providers/Microsoft.Help/troubleshooters/{}",
&self.scope, &self.troubleshooter_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, "2023-09-01-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TroubleshooterResource>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TroubleshooterResource>>;
#[doc = "Returns a future that sends the request and returns the parsed response body."]
#[doc = ""]
#[doc = "You should not normally call this method directly, simply invoke `.await` which implicitly calls `IntoFuture::into_future`."]
#[doc = ""]
#[doc = "See [IntoFuture documentation](https://doc.rust-lang.org/std/future/trait.IntoFuture.html) for more details."]
fn into_future(self) -> Self::IntoFuture {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TroubleshooterResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::TroubleshooterResource = 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) scope: String,
pub(crate) troubleshooter_name: String,
pub(crate) create_troubleshooter_request_body: Option<models::TroubleshooterResource>,
}
impl RequestBuilder {
#[doc = "The required request body for this Troubleshooter resource creation."]
pub fn create_troubleshooter_request_body(
mut self,
create_troubleshooter_request_body: impl Into<models::TroubleshooterResource>,
) -> Self {
self.create_troubleshooter_request_body = Some(create_troubleshooter_request_body.into());
self
}
#[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()));
let req_body = if let Some(create_troubleshooter_request_body) = &this.create_troubleshooter_request_body {
req.insert_header("content-type", "application/json");
azure_core::to_json(create_troubleshooter_request_body)?
} else {
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 = self.client.endpoint().clone();
url.set_path(&format!(
"/{}/providers/Microsoft.Help/troubleshooters/{}",
&self.scope, &self.troubleshooter_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, "2023-09-01-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::TroubleshooterResource>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::TroubleshooterResource>>;
#[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 continue_ {
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
}
pub fn headers(&self) -> Headers {
Headers(self.0.headers())
}
}
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()
}
}
pub struct Headers<'a>(&'a azure_core::headers::Headers);
impl<'a> Headers<'a> {
pub fn location(&self) -> azure_core::Result<&str> {
self.0.get_str(&azure_core::headers::HeaderName::from_static("location"))
}
}
#[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) scope: String,
pub(crate) troubleshooter_name: String,
pub(crate) continue_request_body: Option<models::ContinueRequestBody>,
}
impl RequestBuilder {
#[doc = "The required request body for going to next step in Troubleshooter resource."]
pub fn continue_request_body(mut self, continue_request_body: impl Into<models::ContinueRequestBody>) -> Self {
self.continue_request_body = Some(continue_request_body.into());
self
}
#[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 = if let Some(continue_request_body) = &this.continue_request_body {
req.insert_header("content-type", "application/json");
azure_core::to_json(continue_request_body)?
} else {
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 = self.client.endpoint().clone();
url.set_path(&format!(
"/{}/providers/Microsoft.Help/troubleshooters/{}/continue",
&self.scope, &self.troubleshooter_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, "2023-09-01-preview");
}
Ok(url)
}
}
}
pub mod end {
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
}
pub fn headers(&self) -> Headers {
Headers(self.0.headers())
}
}
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()
}
}
pub struct Headers<'a>(&'a azure_core::headers::Headers);
impl<'a> Headers<'a> {
pub fn location(&self) -> azure_core::Result<&str> {
self.0.get_str(&azure_core::headers::HeaderName::from_static("location"))
}
}
#[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) scope: String,
pub(crate) troubleshooter_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 = self.client.endpoint().clone();
url.set_path(&format!(
"/{}/providers/Microsoft.Help/troubleshooters/{}/end",
&self.scope, &self.troubleshooter_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, "2023-09-01-preview");
}
Ok(url)
}
}
}
pub mod restart {
use super::models;
#[cfg(not(target_arch = "wasm32"))]
use futures::future::BoxFuture;
#[cfg(target_arch = "wasm32")]
use futures::future::LocalBoxFuture as BoxFuture;
#[derive(Debug)]
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RestartTroubleshooterResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::RestartTroubleshooterResponse = 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
}
pub fn headers(&self) -> Headers {
Headers(self.0.headers())
}
}
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()
}
}
pub struct Headers<'a>(&'a azure_core::headers::Headers);
impl<'a> Headers<'a> {
pub fn location(&self) -> azure_core::Result<&str> {
self.0.get_str(&azure_core::headers::HeaderName::from_static("location"))
}
}
#[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) scope: String,
pub(crate) troubleshooter_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 = self.client.endpoint().clone();
url.set_path(&format!(
"/{}/providers/Microsoft.Help/troubleshooters/{}/restart",
&self.scope, &self.troubleshooter_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, "2023-09-01-preview");
}
Ok(url)
}
}
impl std::future::IntoFuture for RequestBuilder {
type Output = azure_core::Result<models::RestartTroubleshooterResponse>;
type IntoFuture = BoxFuture<'static, azure_core::Result<models::RestartTroubleshooterResponse>>;
#[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 })
}
}
}
}