use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl ComputeOptimizerClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request =
SignedRequest::new(http_method, "compute-optimizer", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.0".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AutoScalingGroupConfiguration {
#[serde(rename = "desiredCapacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub desired_capacity: Option<i64>,
#[serde(rename = "instanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type: Option<String>,
#[serde(rename = "maxSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_size: Option<i64>,
#[serde(rename = "minSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_size: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AutoScalingGroupRecommendation {
#[serde(rename = "accountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "autoScalingGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_group_arn: Option<String>,
#[serde(rename = "autoScalingGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_group_name: Option<String>,
#[serde(rename = "currentConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_configuration: Option<AutoScalingGroupConfiguration>,
#[serde(rename = "finding")]
#[serde(skip_serializing_if = "Option::is_none")]
pub finding: Option<String>,
#[serde(rename = "lastRefreshTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_refresh_timestamp: Option<f64>,
#[serde(rename = "lookBackPeriodInDays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub look_back_period_in_days: Option<f64>,
#[serde(rename = "recommendationOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_options: Option<Vec<AutoScalingGroupRecommendationOption>>,
#[serde(rename = "utilizationMetrics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub utilization_metrics: Option<Vec<UtilizationMetric>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AutoScalingGroupRecommendationOption {
#[serde(rename = "configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<AutoScalingGroupConfiguration>,
#[serde(rename = "performanceRisk")]
#[serde(skip_serializing_if = "Option::is_none")]
pub performance_risk: Option<f64>,
#[serde(rename = "projectedUtilizationMetrics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub projected_utilization_metrics: Option<Vec<UtilizationMetric>>,
#[serde(rename = "rank")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rank: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRecommendationExportJobsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<JobFilter>>,
#[serde(rename = "jobIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_ids: Option<Vec<String>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRecommendationExportJobsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "recommendationExportJobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_export_jobs: Option<Vec<RecommendationExportJob>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ExportAutoScalingGroupRecommendationsRequest {
#[serde(rename = "accountIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_ids: Option<Vec<String>>,
#[serde(rename = "fieldsToExport")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fields_to_export: Option<Vec<String>>,
#[serde(rename = "fileFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_format: Option<String>,
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "includeMemberAccounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_member_accounts: Option<bool>,
#[serde(rename = "s3DestinationConfig")]
pub s_3_destination_config: S3DestinationConfig,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExportAutoScalingGroupRecommendationsResponse {
#[serde(rename = "jobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
#[serde(rename = "s3Destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_destination: Option<S3Destination>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExportDestination {
#[serde(rename = "s3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3: Option<S3Destination>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ExportEC2InstanceRecommendationsRequest {
#[serde(rename = "accountIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_ids: Option<Vec<String>>,
#[serde(rename = "fieldsToExport")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fields_to_export: Option<Vec<String>>,
#[serde(rename = "fileFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_format: Option<String>,
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "includeMemberAccounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_member_accounts: Option<bool>,
#[serde(rename = "s3DestinationConfig")]
pub s_3_destination_config: S3DestinationConfig,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExportEC2InstanceRecommendationsResponse {
#[serde(rename = "jobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
#[serde(rename = "s3Destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_destination: Option<S3Destination>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Filter {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAutoScalingGroupRecommendationsRequest {
#[serde(rename = "accountIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_ids: Option<Vec<String>>,
#[serde(rename = "autoScalingGroupArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_group_arns: Option<Vec<String>>,
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAutoScalingGroupRecommendationsResponse {
#[serde(rename = "autoScalingGroupRecommendations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_group_recommendations: Option<Vec<AutoScalingGroupRecommendation>>,
#[serde(rename = "errors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub errors: Option<Vec<GetRecommendationError>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetEC2InstanceRecommendationsRequest {
#[serde(rename = "accountIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_ids: Option<Vec<String>>,
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "instanceArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_arns: Option<Vec<String>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetEC2InstanceRecommendationsResponse {
#[serde(rename = "errors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub errors: Option<Vec<GetRecommendationError>>,
#[serde(rename = "instanceRecommendations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_recommendations: Option<Vec<InstanceRecommendation>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetEC2RecommendationProjectedMetricsRequest {
#[serde(rename = "endTime")]
pub end_time: f64,
#[serde(rename = "instanceArn")]
pub instance_arn: String,
#[serde(rename = "period")]
pub period: i64,
#[serde(rename = "startTime")]
pub start_time: f64,
#[serde(rename = "stat")]
pub stat: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetEC2RecommendationProjectedMetricsResponse {
#[serde(rename = "recommendedOptionProjectedMetrics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommended_option_projected_metrics: Option<Vec<RecommendedOptionProjectedMetric>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetEnrollmentStatusRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetEnrollmentStatusResponse {
#[serde(rename = "memberAccountsEnrolled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub member_accounts_enrolled: Option<bool>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "statusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_reason: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRecommendationError {
#[serde(rename = "code")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[serde(rename = "identifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identifier: Option<String>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRecommendationSummariesRequest {
#[serde(rename = "accountIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_ids: Option<Vec<String>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRecommendationSummariesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "recommendationSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_summaries: Option<Vec<RecommendationSummary>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceRecommendation {
#[serde(rename = "accountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "currentInstanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_instance_type: Option<String>,
#[serde(rename = "finding")]
#[serde(skip_serializing_if = "Option::is_none")]
pub finding: Option<String>,
#[serde(rename = "instanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_arn: Option<String>,
#[serde(rename = "instanceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_name: Option<String>,
#[serde(rename = "lastRefreshTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_refresh_timestamp: Option<f64>,
#[serde(rename = "lookBackPeriodInDays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub look_back_period_in_days: Option<f64>,
#[serde(rename = "recommendationOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_options: Option<Vec<InstanceRecommendationOption>>,
#[serde(rename = "recommendationSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_sources: Option<Vec<RecommendationSource>>,
#[serde(rename = "utilizationMetrics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub utilization_metrics: Option<Vec<UtilizationMetric>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceRecommendationOption {
#[serde(rename = "instanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type: Option<String>,
#[serde(rename = "performanceRisk")]
#[serde(skip_serializing_if = "Option::is_none")]
pub performance_risk: Option<f64>,
#[serde(rename = "projectedUtilizationMetrics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub projected_utilization_metrics: Option<Vec<UtilizationMetric>>,
#[serde(rename = "rank")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rank: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct JobFilter {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProjectedMetric {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "timestamps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timestamps: Option<Vec<f64>>,
#[serde(rename = "values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<f64>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecommendationExportJob {
#[serde(rename = "creationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<f64>,
#[serde(rename = "destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<ExportDestination>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "jobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
#[serde(rename = "lastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<f64>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecommendationSource {
#[serde(rename = "recommendationSourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_source_arn: Option<String>,
#[serde(rename = "recommendationSourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_source_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecommendationSummary {
#[serde(rename = "accountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "recommendationResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation_resource_type: Option<String>,
#[serde(rename = "summaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summaries: Option<Vec<Summary>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecommendedOptionProjectedMetric {
#[serde(rename = "projectedMetrics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub projected_metrics: Option<Vec<ProjectedMetric>>,
#[serde(rename = "rank")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rank: Option<i64>,
#[serde(rename = "recommendedInstanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommended_instance_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct S3Destination {
#[serde(rename = "bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket: Option<String>,
#[serde(rename = "key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "metadataKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata_key: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct S3DestinationConfig {
#[serde(rename = "bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket: Option<String>,
#[serde(rename = "keyPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_prefix: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Summary {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateEnrollmentStatusRequest {
#[serde(rename = "includeMemberAccounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_member_accounts: Option<bool>,
#[serde(rename = "status")]
pub status: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateEnrollmentStatusResponse {
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "statusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_reason: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UtilizationMetric {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "statistic")]
#[serde(skip_serializing_if = "Option::is_none")]
pub statistic: Option<String>,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<f64>,
}
#[derive(Debug, PartialEq)]
pub enum DescribeRecommendationExportJobsError {
AccessDenied(String),
InternalServer(String),
InvalidParameterValue(String),
MissingAuthenticationToken(String),
OptInRequired(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl DescribeRecommendationExportJobsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeRecommendationExportJobsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
DescribeRecommendationExportJobsError::AccessDenied(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(
DescribeRecommendationExportJobsError::InternalServer(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribeRecommendationExportJobsError::InvalidParameterValue(err.msg),
)
}
"MissingAuthenticationToken" => {
return RusotoError::Service(
DescribeRecommendationExportJobsError::MissingAuthenticationToken(err.msg),
)
}
"OptInRequiredException" => {
return RusotoError::Service(
DescribeRecommendationExportJobsError::OptInRequired(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeRecommendationExportJobsError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
DescribeRecommendationExportJobsError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(DescribeRecommendationExportJobsError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRecommendationExportJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRecommendationExportJobsError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DescribeRecommendationExportJobsError::InternalServer(ref cause) => {
write!(f, "{}", cause)
}
DescribeRecommendationExportJobsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeRecommendationExportJobsError::MissingAuthenticationToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeRecommendationExportJobsError::OptInRequired(ref cause) => {
write!(f, "{}", cause)
}
DescribeRecommendationExportJobsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeRecommendationExportJobsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
DescribeRecommendationExportJobsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeRecommendationExportJobsError {}
#[derive(Debug, PartialEq)]
pub enum ExportAutoScalingGroupRecommendationsError {
AccessDenied(String),
InternalServer(String),
InvalidParameterValue(String),
LimitExceeded(String),
MissingAuthenticationToken(String),
OptInRequired(String),
ServiceUnavailable(String),
Throttling(String),
}
impl ExportAutoScalingGroupRecommendationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ExportAutoScalingGroupRecommendationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
ExportAutoScalingGroupRecommendationsError::AccessDenied(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(
ExportAutoScalingGroupRecommendationsError::InternalServer(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
ExportAutoScalingGroupRecommendationsError::InvalidParameterValue(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
ExportAutoScalingGroupRecommendationsError::LimitExceeded(err.msg),
)
}
"MissingAuthenticationToken" => {
return RusotoError::Service(
ExportAutoScalingGroupRecommendationsError::MissingAuthenticationToken(
err.msg,
),
)
}
"OptInRequiredException" => {
return RusotoError::Service(
ExportAutoScalingGroupRecommendationsError::OptInRequired(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
ExportAutoScalingGroupRecommendationsError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(
ExportAutoScalingGroupRecommendationsError::Throttling(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ExportAutoScalingGroupRecommendationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ExportAutoScalingGroupRecommendationsError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
ExportAutoScalingGroupRecommendationsError::InternalServer(ref cause) => {
write!(f, "{}", cause)
}
ExportAutoScalingGroupRecommendationsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ExportAutoScalingGroupRecommendationsError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ExportAutoScalingGroupRecommendationsError::MissingAuthenticationToken(ref cause) => {
write!(f, "{}", cause)
}
ExportAutoScalingGroupRecommendationsError::OptInRequired(ref cause) => {
write!(f, "{}", cause)
}
ExportAutoScalingGroupRecommendationsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
ExportAutoScalingGroupRecommendationsError::Throttling(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ExportAutoScalingGroupRecommendationsError {}
#[derive(Debug, PartialEq)]
pub enum ExportEC2InstanceRecommendationsError {
AccessDenied(String),
InternalServer(String),
InvalidParameterValue(String),
LimitExceeded(String),
MissingAuthenticationToken(String),
OptInRequired(String),
ServiceUnavailable(String),
Throttling(String),
}
impl ExportEC2InstanceRecommendationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ExportEC2InstanceRecommendationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
ExportEC2InstanceRecommendationsError::AccessDenied(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(
ExportEC2InstanceRecommendationsError::InternalServer(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
ExportEC2InstanceRecommendationsError::InvalidParameterValue(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
ExportEC2InstanceRecommendationsError::LimitExceeded(err.msg),
)
}
"MissingAuthenticationToken" => {
return RusotoError::Service(
ExportEC2InstanceRecommendationsError::MissingAuthenticationToken(err.msg),
)
}
"OptInRequiredException" => {
return RusotoError::Service(
ExportEC2InstanceRecommendationsError::OptInRequired(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
ExportEC2InstanceRecommendationsError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(ExportEC2InstanceRecommendationsError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ExportEC2InstanceRecommendationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ExportEC2InstanceRecommendationsError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
ExportEC2InstanceRecommendationsError::InternalServer(ref cause) => {
write!(f, "{}", cause)
}
ExportEC2InstanceRecommendationsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ExportEC2InstanceRecommendationsError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ExportEC2InstanceRecommendationsError::MissingAuthenticationToken(ref cause) => {
write!(f, "{}", cause)
}
ExportEC2InstanceRecommendationsError::OptInRequired(ref cause) => {
write!(f, "{}", cause)
}
ExportEC2InstanceRecommendationsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
ExportEC2InstanceRecommendationsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ExportEC2InstanceRecommendationsError {}
#[derive(Debug, PartialEq)]
pub enum GetAutoScalingGroupRecommendationsError {
AccessDenied(String),
InternalServer(String),
InvalidParameterValue(String),
MissingAuthenticationToken(String),
OptInRequired(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl GetAutoScalingGroupRecommendationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetAutoScalingGroupRecommendationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
GetAutoScalingGroupRecommendationsError::AccessDenied(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(
GetAutoScalingGroupRecommendationsError::InternalServer(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
GetAutoScalingGroupRecommendationsError::InvalidParameterValue(err.msg),
)
}
"MissingAuthenticationToken" => {
return RusotoError::Service(
GetAutoScalingGroupRecommendationsError::MissingAuthenticationToken(
err.msg,
),
)
}
"OptInRequiredException" => {
return RusotoError::Service(
GetAutoScalingGroupRecommendationsError::OptInRequired(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetAutoScalingGroupRecommendationsError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
GetAutoScalingGroupRecommendationsError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(
GetAutoScalingGroupRecommendationsError::Throttling(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAutoScalingGroupRecommendationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAutoScalingGroupRecommendationsError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetAutoScalingGroupRecommendationsError::InternalServer(ref cause) => {
write!(f, "{}", cause)
}
GetAutoScalingGroupRecommendationsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetAutoScalingGroupRecommendationsError::MissingAuthenticationToken(ref cause) => {
write!(f, "{}", cause)
}
GetAutoScalingGroupRecommendationsError::OptInRequired(ref cause) => {
write!(f, "{}", cause)
}
GetAutoScalingGroupRecommendationsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetAutoScalingGroupRecommendationsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
GetAutoScalingGroupRecommendationsError::Throttling(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetAutoScalingGroupRecommendationsError {}
#[derive(Debug, PartialEq)]
pub enum GetEC2InstanceRecommendationsError {
AccessDenied(String),
InternalServer(String),
InvalidParameterValue(String),
MissingAuthenticationToken(String),
OptInRequired(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl GetEC2InstanceRecommendationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetEC2InstanceRecommendationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetEC2InstanceRecommendationsError::AccessDenied(
err.msg,
))
}
"InternalServerException" => {
return RusotoError::Service(
GetEC2InstanceRecommendationsError::InternalServer(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
GetEC2InstanceRecommendationsError::InvalidParameterValue(err.msg),
)
}
"MissingAuthenticationToken" => {
return RusotoError::Service(
GetEC2InstanceRecommendationsError::MissingAuthenticationToken(err.msg),
)
}
"OptInRequiredException" => {
return RusotoError::Service(GetEC2InstanceRecommendationsError::OptInRequired(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetEC2InstanceRecommendationsError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
GetEC2InstanceRecommendationsError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(GetEC2InstanceRecommendationsError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetEC2InstanceRecommendationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetEC2InstanceRecommendationsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetEC2InstanceRecommendationsError::InternalServer(ref cause) => write!(f, "{}", cause),
GetEC2InstanceRecommendationsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetEC2InstanceRecommendationsError::MissingAuthenticationToken(ref cause) => {
write!(f, "{}", cause)
}
GetEC2InstanceRecommendationsError::OptInRequired(ref cause) => write!(f, "{}", cause),
GetEC2InstanceRecommendationsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetEC2InstanceRecommendationsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
GetEC2InstanceRecommendationsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetEC2InstanceRecommendationsError {}
#[derive(Debug, PartialEq)]
pub enum GetEC2RecommendationProjectedMetricsError {
AccessDenied(String),
InternalServer(String),
InvalidParameterValue(String),
MissingAuthenticationToken(String),
OptInRequired(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl GetEC2RecommendationProjectedMetricsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetEC2RecommendationProjectedMetricsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
GetEC2RecommendationProjectedMetricsError::AccessDenied(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(
GetEC2RecommendationProjectedMetricsError::InternalServer(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
GetEC2RecommendationProjectedMetricsError::InvalidParameterValue(err.msg),
)
}
"MissingAuthenticationToken" => {
return RusotoError::Service(
GetEC2RecommendationProjectedMetricsError::MissingAuthenticationToken(
err.msg,
),
)
}
"OptInRequiredException" => {
return RusotoError::Service(
GetEC2RecommendationProjectedMetricsError::OptInRequired(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetEC2RecommendationProjectedMetricsError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
GetEC2RecommendationProjectedMetricsError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(
GetEC2RecommendationProjectedMetricsError::Throttling(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetEC2RecommendationProjectedMetricsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetEC2RecommendationProjectedMetricsError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetEC2RecommendationProjectedMetricsError::InternalServer(ref cause) => {
write!(f, "{}", cause)
}
GetEC2RecommendationProjectedMetricsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetEC2RecommendationProjectedMetricsError::MissingAuthenticationToken(ref cause) => {
write!(f, "{}", cause)
}
GetEC2RecommendationProjectedMetricsError::OptInRequired(ref cause) => {
write!(f, "{}", cause)
}
GetEC2RecommendationProjectedMetricsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetEC2RecommendationProjectedMetricsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
GetEC2RecommendationProjectedMetricsError::Throttling(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetEC2RecommendationProjectedMetricsError {}
#[derive(Debug, PartialEq)]
pub enum GetEnrollmentStatusError {
AccessDenied(String),
InternalServer(String),
InvalidParameterValue(String),
MissingAuthenticationToken(String),
ServiceUnavailable(String),
Throttling(String),
}
impl GetEnrollmentStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetEnrollmentStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetEnrollmentStatusError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(GetEnrollmentStatusError::InternalServer(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(GetEnrollmentStatusError::InvalidParameterValue(
err.msg,
))
}
"MissingAuthenticationToken" => {
return RusotoError::Service(
GetEnrollmentStatusError::MissingAuthenticationToken(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetEnrollmentStatusError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(GetEnrollmentStatusError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetEnrollmentStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetEnrollmentStatusError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetEnrollmentStatusError::InternalServer(ref cause) => write!(f, "{}", cause),
GetEnrollmentStatusError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetEnrollmentStatusError::MissingAuthenticationToken(ref cause) => {
write!(f, "{}", cause)
}
GetEnrollmentStatusError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
GetEnrollmentStatusError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetEnrollmentStatusError {}
#[derive(Debug, PartialEq)]
pub enum GetRecommendationSummariesError {
AccessDenied(String),
InternalServer(String),
InvalidParameterValue(String),
MissingAuthenticationToken(String),
OptInRequired(String),
ServiceUnavailable(String),
Throttling(String),
}
impl GetRecommendationSummariesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetRecommendationSummariesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetRecommendationSummariesError::AccessDenied(
err.msg,
))
}
"InternalServerException" => {
return RusotoError::Service(GetRecommendationSummariesError::InternalServer(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(
GetRecommendationSummariesError::InvalidParameterValue(err.msg),
)
}
"MissingAuthenticationToken" => {
return RusotoError::Service(
GetRecommendationSummariesError::MissingAuthenticationToken(err.msg),
)
}
"OptInRequiredException" => {
return RusotoError::Service(GetRecommendationSummariesError::OptInRequired(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
GetRecommendationSummariesError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(GetRecommendationSummariesError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRecommendationSummariesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRecommendationSummariesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRecommendationSummariesError::InternalServer(ref cause) => write!(f, "{}", cause),
GetRecommendationSummariesError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetRecommendationSummariesError::MissingAuthenticationToken(ref cause) => {
write!(f, "{}", cause)
}
GetRecommendationSummariesError::OptInRequired(ref cause) => write!(f, "{}", cause),
GetRecommendationSummariesError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
GetRecommendationSummariesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRecommendationSummariesError {}
#[derive(Debug, PartialEq)]
pub enum UpdateEnrollmentStatusError {
AccessDenied(String),
InternalServer(String),
InvalidParameterValue(String),
MissingAuthenticationToken(String),
ServiceUnavailable(String),
Throttling(String),
}
impl UpdateEnrollmentStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateEnrollmentStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateEnrollmentStatusError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(UpdateEnrollmentStatusError::InternalServer(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(
UpdateEnrollmentStatusError::InvalidParameterValue(err.msg),
)
}
"MissingAuthenticationToken" => {
return RusotoError::Service(
UpdateEnrollmentStatusError::MissingAuthenticationToken(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdateEnrollmentStatusError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateEnrollmentStatusError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateEnrollmentStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateEnrollmentStatusError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateEnrollmentStatusError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateEnrollmentStatusError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
UpdateEnrollmentStatusError::MissingAuthenticationToken(ref cause) => {
write!(f, "{}", cause)
}
UpdateEnrollmentStatusError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
UpdateEnrollmentStatusError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateEnrollmentStatusError {}
#[async_trait]
pub trait ComputeOptimizer {
async fn describe_recommendation_export_jobs(
&self,
input: DescribeRecommendationExportJobsRequest,
) -> Result<
DescribeRecommendationExportJobsResponse,
RusotoError<DescribeRecommendationExportJobsError>,
>;
async fn export_auto_scaling_group_recommendations(
&self,
input: ExportAutoScalingGroupRecommendationsRequest,
) -> Result<
ExportAutoScalingGroupRecommendationsResponse,
RusotoError<ExportAutoScalingGroupRecommendationsError>,
>;
async fn export_ec2_instance_recommendations(
&self,
input: ExportEC2InstanceRecommendationsRequest,
) -> Result<
ExportEC2InstanceRecommendationsResponse,
RusotoError<ExportEC2InstanceRecommendationsError>,
>;
async fn get_auto_scaling_group_recommendations(
&self,
input: GetAutoScalingGroupRecommendationsRequest,
) -> Result<
GetAutoScalingGroupRecommendationsResponse,
RusotoError<GetAutoScalingGroupRecommendationsError>,
>;
async fn get_ec2_instance_recommendations(
&self,
input: GetEC2InstanceRecommendationsRequest,
) -> Result<
GetEC2InstanceRecommendationsResponse,
RusotoError<GetEC2InstanceRecommendationsError>,
>;
async fn get_ec2_recommendation_projected_metrics(
&self,
input: GetEC2RecommendationProjectedMetricsRequest,
) -> Result<
GetEC2RecommendationProjectedMetricsResponse,
RusotoError<GetEC2RecommendationProjectedMetricsError>,
>;
async fn get_enrollment_status(
&self,
) -> Result<GetEnrollmentStatusResponse, RusotoError<GetEnrollmentStatusError>>;
async fn get_recommendation_summaries(
&self,
input: GetRecommendationSummariesRequest,
) -> Result<GetRecommendationSummariesResponse, RusotoError<GetRecommendationSummariesError>>;
async fn update_enrollment_status(
&self,
input: UpdateEnrollmentStatusRequest,
) -> Result<UpdateEnrollmentStatusResponse, RusotoError<UpdateEnrollmentStatusError>>;
}
#[derive(Clone)]
pub struct ComputeOptimizerClient {
client: Client,
region: region::Region,
}
impl ComputeOptimizerClient {
pub fn new(region: region::Region) -> ComputeOptimizerClient {
ComputeOptimizerClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ComputeOptimizerClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ComputeOptimizerClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ComputeOptimizerClient {
ComputeOptimizerClient { client, region }
}
}
#[async_trait]
impl ComputeOptimizer for ComputeOptimizerClient {
async fn describe_recommendation_export_jobs(
&self,
input: DescribeRecommendationExportJobsRequest,
) -> Result<
DescribeRecommendationExportJobsResponse,
RusotoError<DescribeRecommendationExportJobsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComputeOptimizerService.DescribeRecommendationExportJobs",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeRecommendationExportJobsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRecommendationExportJobsResponse, _>()
}
async fn export_auto_scaling_group_recommendations(
&self,
input: ExportAutoScalingGroupRecommendationsRequest,
) -> Result<
ExportAutoScalingGroupRecommendationsResponse,
RusotoError<ExportAutoScalingGroupRecommendationsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComputeOptimizerService.ExportAutoScalingGroupRecommendations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ExportAutoScalingGroupRecommendationsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ExportAutoScalingGroupRecommendationsResponse, _>()
}
async fn export_ec2_instance_recommendations(
&self,
input: ExportEC2InstanceRecommendationsRequest,
) -> Result<
ExportEC2InstanceRecommendationsResponse,
RusotoError<ExportEC2InstanceRecommendationsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComputeOptimizerService.ExportEC2InstanceRecommendations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ExportEC2InstanceRecommendationsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ExportEC2InstanceRecommendationsResponse, _>()
}
async fn get_auto_scaling_group_recommendations(
&self,
input: GetAutoScalingGroupRecommendationsRequest,
) -> Result<
GetAutoScalingGroupRecommendationsResponse,
RusotoError<GetAutoScalingGroupRecommendationsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComputeOptimizerService.GetAutoScalingGroupRecommendations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetAutoScalingGroupRecommendationsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetAutoScalingGroupRecommendationsResponse, _>()
}
async fn get_ec2_instance_recommendations(
&self,
input: GetEC2InstanceRecommendationsRequest,
) -> Result<
GetEC2InstanceRecommendationsResponse,
RusotoError<GetEC2InstanceRecommendationsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComputeOptimizerService.GetEC2InstanceRecommendations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetEC2InstanceRecommendationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetEC2InstanceRecommendationsResponse, _>()
}
async fn get_ec2_recommendation_projected_metrics(
&self,
input: GetEC2RecommendationProjectedMetricsRequest,
) -> Result<
GetEC2RecommendationProjectedMetricsResponse,
RusotoError<GetEC2RecommendationProjectedMetricsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComputeOptimizerService.GetEC2RecommendationProjectedMetrics",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetEC2RecommendationProjectedMetricsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetEC2RecommendationProjectedMetricsResponse, _>()
}
async fn get_enrollment_status(
&self,
) -> Result<GetEnrollmentStatusResponse, RusotoError<GetEnrollmentStatusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComputeOptimizerService.GetEnrollmentStatus",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, GetEnrollmentStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetEnrollmentStatusResponse, _>()
}
async fn get_recommendation_summaries(
&self,
input: GetRecommendationSummariesRequest,
) -> Result<GetRecommendationSummariesResponse, RusotoError<GetRecommendationSummariesError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComputeOptimizerService.GetRecommendationSummaries",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRecommendationSummariesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRecommendationSummariesResponse, _>()
}
async fn update_enrollment_status(
&self,
input: UpdateEnrollmentStatusRequest,
) -> Result<UpdateEnrollmentStatusResponse, RusotoError<UpdateEnrollmentStatusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ComputeOptimizerService.UpdateEnrollmentStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateEnrollmentStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateEnrollmentStatusResponse, _>()
}
}