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::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Application {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Applications {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<Application>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Configuration {
pub configuration_version: Option<String>,
pub content: Option<bytes::Bytes>,
pub content_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfigurationProfile {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LocationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_uri: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "RetrievalRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retrieval_role_arn: Option<String>,
#[serde(rename = "Validators")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validators: Option<Vec<Validator>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfigurationProfileSummary {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LocationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_uri: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ValidatorTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validator_types: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfigurationProfiles {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<ConfigurationProfileSummary>>,
#[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 CreateApplicationRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateConfigurationProfileRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LocationUri")]
pub location_uri: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RetrievalRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retrieval_role_arn: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Validators")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validators: Option<Vec<Validator>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDeploymentStrategyRequest {
#[serde(rename = "DeploymentDurationInMinutes")]
pub deployment_duration_in_minutes: i64,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "FinalBakeTimeInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub final_bake_time_in_minutes: Option<i64>,
#[serde(rename = "GrowthFactor")]
pub growth_factor: f32,
#[serde(rename = "GrowthType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub growth_type: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "ReplicateTo")]
pub replicate_to: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateEnvironmentRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Monitors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monitors: Option<Vec<Monitor>>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateHostedConfigurationVersionRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "ConfigurationProfileId")]
pub configuration_profile_id: String,
#[serde(rename = "Content")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
pub content: bytes::Bytes,
#[serde(rename = "ContentType")]
pub content_type: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LatestVersionNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_number: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApplicationRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteConfigurationProfileRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "ConfigurationProfileId")]
pub configuration_profile_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDeploymentStrategyRequest {
#[serde(rename = "DeploymentStrategyId")]
pub deployment_strategy_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteEnvironmentRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "EnvironmentId")]
pub environment_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteHostedConfigurationVersionRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "ConfigurationProfileId")]
pub configuration_profile_id: String,
#[serde(rename = "VersionNumber")]
pub version_number: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Deployment {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "CompletedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completed_at: Option<f64>,
#[serde(rename = "ConfigurationLocationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_location_uri: Option<String>,
#[serde(rename = "ConfigurationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_name: Option<String>,
#[serde(rename = "ConfigurationProfileId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_profile_id: Option<String>,
#[serde(rename = "ConfigurationVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_version: Option<String>,
#[serde(rename = "DeploymentDurationInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_duration_in_minutes: Option<i64>,
#[serde(rename = "DeploymentNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_number: Option<i64>,
#[serde(rename = "DeploymentStrategyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_strategy_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "EnvironmentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_id: Option<String>,
#[serde(rename = "EventLog")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_log: Option<Vec<DeploymentEvent>>,
#[serde(rename = "FinalBakeTimeInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub final_bake_time_in_minutes: Option<i64>,
#[serde(rename = "GrowthFactor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub growth_factor: Option<f32>,
#[serde(rename = "GrowthType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub growth_type: Option<String>,
#[serde(rename = "PercentageComplete")]
#[serde(skip_serializing_if = "Option::is_none")]
pub percentage_complete: Option<f32>,
#[serde(rename = "StartedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub started_at: Option<f64>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeploymentEvent {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "EventType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_type: Option<String>,
#[serde(rename = "OccurredAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub occurred_at: Option<f64>,
#[serde(rename = "TriggeredBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub triggered_by: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeploymentStrategies {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<DeploymentStrategy>>,
#[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 DeploymentStrategy {
#[serde(rename = "DeploymentDurationInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_duration_in_minutes: Option<i64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "FinalBakeTimeInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub final_bake_time_in_minutes: Option<i64>,
#[serde(rename = "GrowthFactor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub growth_factor: Option<f32>,
#[serde(rename = "GrowthType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub growth_type: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ReplicateTo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replicate_to: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeploymentSummary {
#[serde(rename = "CompletedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completed_at: Option<f64>,
#[serde(rename = "ConfigurationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_name: Option<String>,
#[serde(rename = "ConfigurationVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_version: Option<String>,
#[serde(rename = "DeploymentDurationInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_duration_in_minutes: Option<i64>,
#[serde(rename = "DeploymentNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_number: Option<i64>,
#[serde(rename = "FinalBakeTimeInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub final_bake_time_in_minutes: Option<i64>,
#[serde(rename = "GrowthFactor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub growth_factor: Option<f32>,
#[serde(rename = "GrowthType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub growth_type: Option<String>,
#[serde(rename = "PercentageComplete")]
#[serde(skip_serializing_if = "Option::is_none")]
pub percentage_complete: Option<f32>,
#[serde(rename = "StartedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub started_at: Option<f64>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Deployments {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<DeploymentSummary>>,
#[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 Environment {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Monitors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monitors: Option<Vec<Monitor>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Environments {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<Environment>>,
#[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 GetApplicationRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetConfigurationProfileRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "ConfigurationProfileId")]
pub configuration_profile_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetConfigurationRequest {
#[serde(rename = "Application")]
pub application: String,
#[serde(rename = "ClientConfigurationVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_configuration_version: Option<String>,
#[serde(rename = "ClientId")]
pub client_id: String,
#[serde(rename = "Configuration")]
pub configuration: String,
#[serde(rename = "Environment")]
pub environment: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeploymentRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "DeploymentNumber")]
pub deployment_number: i64,
#[serde(rename = "EnvironmentId")]
pub environment_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeploymentStrategyRequest {
#[serde(rename = "DeploymentStrategyId")]
pub deployment_strategy_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetEnvironmentRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "EnvironmentId")]
pub environment_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetHostedConfigurationVersionRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "ConfigurationProfileId")]
pub configuration_profile_id: String,
#[serde(rename = "VersionNumber")]
pub version_number: i64,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct HostedConfigurationVersion {
pub application_id: Option<String>,
pub configuration_profile_id: Option<String>,
pub content: Option<bytes::Bytes>,
pub content_type: Option<String>,
pub description: Option<String>,
pub version_number: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HostedConfigurationVersionSummary {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "ConfigurationProfileId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_profile_id: Option<String>,
#[serde(rename = "ContentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "VersionNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_number: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HostedConfigurationVersions {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<HostedConfigurationVersionSummary>>,
#[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 ListApplicationsRequest {
#[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, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListConfigurationProfilesRequest {
#[serde(rename = "ApplicationId")]
pub application_id: 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, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDeploymentStrategiesRequest {
#[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, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDeploymentsRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "EnvironmentId")]
pub environment_id: 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, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListEnvironmentsRequest {
#[serde(rename = "ApplicationId")]
pub application_id: 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, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListHostedConfigurationVersionsRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "ConfigurationProfileId")]
pub configuration_profile_id: 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, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Monitor {
#[serde(rename = "AlarmArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alarm_arn: Option<String>,
#[serde(rename = "AlarmRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alarm_role_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceTags {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartDeploymentRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "ConfigurationProfileId")]
pub configuration_profile_id: String,
#[serde(rename = "ConfigurationVersion")]
pub configuration_version: String,
#[serde(rename = "DeploymentStrategyId")]
pub deployment_strategy_id: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "EnvironmentId")]
pub environment_id: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopDeploymentRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "DeploymentNumber")]
pub deployment_number: i64,
#[serde(rename = "EnvironmentId")]
pub environment_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateApplicationRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateConfigurationProfileRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "ConfigurationProfileId")]
pub configuration_profile_id: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "RetrievalRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retrieval_role_arn: Option<String>,
#[serde(rename = "Validators")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validators: Option<Vec<Validator>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDeploymentStrategyRequest {
#[serde(rename = "DeploymentDurationInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_duration_in_minutes: Option<i64>,
#[serde(rename = "DeploymentStrategyId")]
pub deployment_strategy_id: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "FinalBakeTimeInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub final_bake_time_in_minutes: Option<i64>,
#[serde(rename = "GrowthFactor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub growth_factor: Option<f32>,
#[serde(rename = "GrowthType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub growth_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateEnvironmentRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "EnvironmentId")]
pub environment_id: String,
#[serde(rename = "Monitors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monitors: Option<Vec<Monitor>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ValidateConfigurationRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "ConfigurationProfileId")]
pub configuration_profile_id: String,
#[serde(rename = "ConfigurationVersion")]
pub configuration_version: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Validator {
#[serde(rename = "Content")]
pub content: String,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Debug, PartialEq)]
pub enum CreateApplicationError {
BadRequest(String),
InternalServer(String),
}
impl CreateApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateApplicationError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(CreateApplicationError::InternalServer(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateApplicationError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateApplicationError {}
#[derive(Debug, PartialEq)]
pub enum CreateConfigurationProfileError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl CreateConfigurationProfileError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateConfigurationProfileError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateConfigurationProfileError::BadRequest(
err.msg,
))
}
"InternalServerException" => {
return RusotoError::Service(CreateConfigurationProfileError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateConfigurationProfileError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateConfigurationProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateConfigurationProfileError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateConfigurationProfileError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateConfigurationProfileError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateConfigurationProfileError {}
#[derive(Debug, PartialEq)]
pub enum CreateDeploymentStrategyError {
BadRequest(String),
InternalServer(String),
}
impl CreateDeploymentStrategyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDeploymentStrategyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateDeploymentStrategyError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(CreateDeploymentStrategyError::InternalServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDeploymentStrategyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDeploymentStrategyError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateDeploymentStrategyError::InternalServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDeploymentStrategyError {}
#[derive(Debug, PartialEq)]
pub enum CreateEnvironmentError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl CreateEnvironmentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateEnvironmentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateEnvironmentError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(CreateEnvironmentError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateEnvironmentError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateEnvironmentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateEnvironmentError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateEnvironmentError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateEnvironmentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateEnvironmentError {}
#[derive(Debug, PartialEq)]
pub enum CreateHostedConfigurationVersionError {
BadRequest(String),
Conflict(String),
InternalServer(String),
PayloadTooLarge(String),
ResourceNotFound(String),
ServiceQuotaExceeded(String),
}
impl CreateHostedConfigurationVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateHostedConfigurationVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateHostedConfigurationVersionError::BadRequest(
err.msg,
))
}
"ConflictException" => {
return RusotoError::Service(CreateHostedConfigurationVersionError::Conflict(
err.msg,
))
}
"InternalServerException" => {
return RusotoError::Service(
CreateHostedConfigurationVersionError::InternalServer(err.msg),
)
}
"PayloadTooLargeException" => {
return RusotoError::Service(
CreateHostedConfigurationVersionError::PayloadTooLarge(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
CreateHostedConfigurationVersionError::ResourceNotFound(err.msg),
)
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(
CreateHostedConfigurationVersionError::ServiceQuotaExceeded(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateHostedConfigurationVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateHostedConfigurationVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateHostedConfigurationVersionError::Conflict(ref cause) => write!(f, "{}", cause),
CreateHostedConfigurationVersionError::InternalServer(ref cause) => {
write!(f, "{}", cause)
}
CreateHostedConfigurationVersionError::PayloadTooLarge(ref cause) => {
write!(f, "{}", cause)
}
CreateHostedConfigurationVersionError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
CreateHostedConfigurationVersionError::ServiceQuotaExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateHostedConfigurationVersionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl DeleteApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteApplicationError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DeleteApplicationError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteApplicationError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApplicationError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteApplicationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteConfigurationProfileError {
BadRequest(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
}
impl DeleteConfigurationProfileError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteConfigurationProfileError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteConfigurationProfileError::BadRequest(
err.msg,
))
}
"ConflictException" => {
return RusotoError::Service(DeleteConfigurationProfileError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DeleteConfigurationProfileError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteConfigurationProfileError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteConfigurationProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteConfigurationProfileError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteConfigurationProfileError::Conflict(ref cause) => write!(f, "{}", cause),
DeleteConfigurationProfileError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteConfigurationProfileError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteConfigurationProfileError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDeploymentStrategyError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl DeleteDeploymentStrategyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDeploymentStrategyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteDeploymentStrategyError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DeleteDeploymentStrategyError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteDeploymentStrategyError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDeploymentStrategyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDeploymentStrategyError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteDeploymentStrategyError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteDeploymentStrategyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDeploymentStrategyError {}
#[derive(Debug, PartialEq)]
pub enum DeleteEnvironmentError {
BadRequest(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
}
impl DeleteEnvironmentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteEnvironmentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteEnvironmentError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(DeleteEnvironmentError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DeleteEnvironmentError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteEnvironmentError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteEnvironmentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteEnvironmentError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentError::Conflict(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteEnvironmentError {}
#[derive(Debug, PartialEq)]
pub enum DeleteHostedConfigurationVersionError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl DeleteHostedConfigurationVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteHostedConfigurationVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteHostedConfigurationVersionError::BadRequest(
err.msg,
))
}
"InternalServerException" => {
return RusotoError::Service(
DeleteHostedConfigurationVersionError::InternalServer(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteHostedConfigurationVersionError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteHostedConfigurationVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteHostedConfigurationVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteHostedConfigurationVersionError::InternalServer(ref cause) => {
write!(f, "{}", cause)
}
DeleteHostedConfigurationVersionError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteHostedConfigurationVersionError {}
#[derive(Debug, PartialEq)]
pub enum GetApplicationError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl GetApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetApplicationError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(GetApplicationError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetApplicationError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetApplicationError::BadRequest(ref cause) => write!(f, "{}", cause),
GetApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
GetApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetApplicationError {}
#[derive(Debug, PartialEq)]
pub enum GetConfigurationError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl GetConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetConfigurationError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(GetConfigurationError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetConfigurationError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetConfigurationError::BadRequest(ref cause) => write!(f, "{}", cause),
GetConfigurationError::InternalServer(ref cause) => write!(f, "{}", cause),
GetConfigurationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum GetConfigurationProfileError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl GetConfigurationProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetConfigurationProfileError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetConfigurationProfileError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(GetConfigurationProfileError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetConfigurationProfileError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetConfigurationProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetConfigurationProfileError::BadRequest(ref cause) => write!(f, "{}", cause),
GetConfigurationProfileError::InternalServer(ref cause) => write!(f, "{}", cause),
GetConfigurationProfileError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetConfigurationProfileError {}
#[derive(Debug, PartialEq)]
pub enum GetDeploymentError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl GetDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeploymentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDeploymentError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(GetDeploymentError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetDeploymentError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeploymentError::BadRequest(ref cause) => write!(f, "{}", cause),
GetDeploymentError::InternalServer(ref cause) => write!(f, "{}", cause),
GetDeploymentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum GetDeploymentStrategyError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl GetDeploymentStrategyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeploymentStrategyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDeploymentStrategyError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(GetDeploymentStrategyError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetDeploymentStrategyError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeploymentStrategyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeploymentStrategyError::BadRequest(ref cause) => write!(f, "{}", cause),
GetDeploymentStrategyError::InternalServer(ref cause) => write!(f, "{}", cause),
GetDeploymentStrategyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeploymentStrategyError {}
#[derive(Debug, PartialEq)]
pub enum GetEnvironmentError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl GetEnvironmentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetEnvironmentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetEnvironmentError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(GetEnvironmentError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetEnvironmentError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetEnvironmentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetEnvironmentError::BadRequest(ref cause) => write!(f, "{}", cause),
GetEnvironmentError::InternalServer(ref cause) => write!(f, "{}", cause),
GetEnvironmentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetEnvironmentError {}
#[derive(Debug, PartialEq)]
pub enum GetHostedConfigurationVersionError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl GetHostedConfigurationVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetHostedConfigurationVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetHostedConfigurationVersionError::BadRequest(
err.msg,
))
}
"InternalServerException" => {
return RusotoError::Service(
GetHostedConfigurationVersionError::InternalServer(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetHostedConfigurationVersionError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetHostedConfigurationVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetHostedConfigurationVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
GetHostedConfigurationVersionError::InternalServer(ref cause) => write!(f, "{}", cause),
GetHostedConfigurationVersionError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetHostedConfigurationVersionError {}
#[derive(Debug, PartialEq)]
pub enum ListApplicationsError {
BadRequest(String),
InternalServer(String),
}
impl ListApplicationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListApplicationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListApplicationsError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ListApplicationsError::InternalServer(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListApplicationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListApplicationsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListApplicationsError::InternalServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListApplicationsError {}
#[derive(Debug, PartialEq)]
pub enum ListConfigurationProfilesError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl ListConfigurationProfilesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListConfigurationProfilesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListConfigurationProfilesError::BadRequest(
err.msg,
))
}
"InternalServerException" => {
return RusotoError::Service(ListConfigurationProfilesError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListConfigurationProfilesError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListConfigurationProfilesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListConfigurationProfilesError::BadRequest(ref cause) => write!(f, "{}", cause),
ListConfigurationProfilesError::InternalServer(ref cause) => write!(f, "{}", cause),
ListConfigurationProfilesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListConfigurationProfilesError {}
#[derive(Debug, PartialEq)]
pub enum ListDeploymentStrategiesError {
BadRequest(String),
InternalServer(String),
}
impl ListDeploymentStrategiesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDeploymentStrategiesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListDeploymentStrategiesError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ListDeploymentStrategiesError::InternalServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDeploymentStrategiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDeploymentStrategiesError::BadRequest(ref cause) => write!(f, "{}", cause),
ListDeploymentStrategiesError::InternalServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDeploymentStrategiesError {}
#[derive(Debug, PartialEq)]
pub enum ListDeploymentsError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl ListDeploymentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDeploymentsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListDeploymentsError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ListDeploymentsError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListDeploymentsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDeploymentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDeploymentsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListDeploymentsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListDeploymentsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDeploymentsError {}
#[derive(Debug, PartialEq)]
pub enum ListEnvironmentsError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl ListEnvironmentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListEnvironmentsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListEnvironmentsError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ListEnvironmentsError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListEnvironmentsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListEnvironmentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListEnvironmentsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListEnvironmentsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListEnvironmentsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListEnvironmentsError {}
#[derive(Debug, PartialEq)]
pub enum ListHostedConfigurationVersionsError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl ListHostedConfigurationVersionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListHostedConfigurationVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListHostedConfigurationVersionsError::BadRequest(
err.msg,
))
}
"InternalServerException" => {
return RusotoError::Service(
ListHostedConfigurationVersionsError::InternalServer(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListHostedConfigurationVersionsError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListHostedConfigurationVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListHostedConfigurationVersionsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListHostedConfigurationVersionsError::InternalServer(ref cause) => {
write!(f, "{}", cause)
}
ListHostedConfigurationVersionsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListHostedConfigurationVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListTagsForResourceError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ListTagsForResourceError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum StartDeploymentError {
BadRequest(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
}
impl StartDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartDeploymentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StartDeploymentError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(StartDeploymentError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(StartDeploymentError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StartDeploymentError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartDeploymentError::BadRequest(ref cause) => write!(f, "{}", cause),
StartDeploymentError::Conflict(ref cause) => write!(f, "{}", cause),
StartDeploymentError::InternalServer(ref cause) => write!(f, "{}", cause),
StartDeploymentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum StopDeploymentError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl StopDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopDeploymentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StopDeploymentError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(StopDeploymentError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StopDeploymentError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopDeploymentError::BadRequest(ref cause) => write!(f, "{}", cause),
StopDeploymentError::InternalServer(ref cause) => write!(f, "{}", cause),
StopDeploymentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(TagResourceError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(TagResourceError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UntagResourceError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(UntagResourceError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateApplicationError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl UpdateApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateApplicationError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(UpdateApplicationError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateApplicationError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateApplicationError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateApplicationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateConfigurationProfileError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl UpdateConfigurationProfileError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateConfigurationProfileError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateConfigurationProfileError::BadRequest(
err.msg,
))
}
"InternalServerException" => {
return RusotoError::Service(UpdateConfigurationProfileError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateConfigurationProfileError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateConfigurationProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateConfigurationProfileError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateConfigurationProfileError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateConfigurationProfileError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateConfigurationProfileError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDeploymentStrategyError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl UpdateDeploymentStrategyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDeploymentStrategyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateDeploymentStrategyError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(UpdateDeploymentStrategyError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateDeploymentStrategyError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDeploymentStrategyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDeploymentStrategyError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateDeploymentStrategyError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateDeploymentStrategyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDeploymentStrategyError {}
#[derive(Debug, PartialEq)]
pub enum UpdateEnvironmentError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl UpdateEnvironmentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateEnvironmentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateEnvironmentError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(UpdateEnvironmentError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateEnvironmentError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateEnvironmentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateEnvironmentError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateEnvironmentError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateEnvironmentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateEnvironmentError {}
#[derive(Debug, PartialEq)]
pub enum ValidateConfigurationError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl ValidateConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ValidateConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ValidateConfigurationError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ValidateConfigurationError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ValidateConfigurationError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ValidateConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ValidateConfigurationError::BadRequest(ref cause) => write!(f, "{}", cause),
ValidateConfigurationError::InternalServer(ref cause) => write!(f, "{}", cause),
ValidateConfigurationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ValidateConfigurationError {}
#[async_trait]
pub trait AppConfig {
async fn create_application(
&self,
input: CreateApplicationRequest,
) -> Result<Application, RusotoError<CreateApplicationError>>;
async fn create_configuration_profile(
&self,
input: CreateConfigurationProfileRequest,
) -> Result<ConfigurationProfile, RusotoError<CreateConfigurationProfileError>>;
async fn create_deployment_strategy(
&self,
input: CreateDeploymentStrategyRequest,
) -> Result<DeploymentStrategy, RusotoError<CreateDeploymentStrategyError>>;
async fn create_environment(
&self,
input: CreateEnvironmentRequest,
) -> Result<Environment, RusotoError<CreateEnvironmentError>>;
async fn create_hosted_configuration_version(
&self,
input: CreateHostedConfigurationVersionRequest,
) -> Result<HostedConfigurationVersion, RusotoError<CreateHostedConfigurationVersionError>>;
async fn delete_application(
&self,
input: DeleteApplicationRequest,
) -> Result<(), RusotoError<DeleteApplicationError>>;
async fn delete_configuration_profile(
&self,
input: DeleteConfigurationProfileRequest,
) -> Result<(), RusotoError<DeleteConfigurationProfileError>>;
async fn delete_deployment_strategy(
&self,
input: DeleteDeploymentStrategyRequest,
) -> Result<(), RusotoError<DeleteDeploymentStrategyError>>;
async fn delete_environment(
&self,
input: DeleteEnvironmentRequest,
) -> Result<(), RusotoError<DeleteEnvironmentError>>;
async fn delete_hosted_configuration_version(
&self,
input: DeleteHostedConfigurationVersionRequest,
) -> Result<(), RusotoError<DeleteHostedConfigurationVersionError>>;
async fn get_application(
&self,
input: GetApplicationRequest,
) -> Result<Application, RusotoError<GetApplicationError>>;
async fn get_configuration(
&self,
input: GetConfigurationRequest,
) -> Result<Configuration, RusotoError<GetConfigurationError>>;
async fn get_configuration_profile(
&self,
input: GetConfigurationProfileRequest,
) -> Result<ConfigurationProfile, RusotoError<GetConfigurationProfileError>>;
async fn get_deployment(
&self,
input: GetDeploymentRequest,
) -> Result<Deployment, RusotoError<GetDeploymentError>>;
async fn get_deployment_strategy(
&self,
input: GetDeploymentStrategyRequest,
) -> Result<DeploymentStrategy, RusotoError<GetDeploymentStrategyError>>;
async fn get_environment(
&self,
input: GetEnvironmentRequest,
) -> Result<Environment, RusotoError<GetEnvironmentError>>;
async fn get_hosted_configuration_version(
&self,
input: GetHostedConfigurationVersionRequest,
) -> Result<HostedConfigurationVersion, RusotoError<GetHostedConfigurationVersionError>>;
async fn list_applications(
&self,
input: ListApplicationsRequest,
) -> Result<Applications, RusotoError<ListApplicationsError>>;
async fn list_configuration_profiles(
&self,
input: ListConfigurationProfilesRequest,
) -> Result<ConfigurationProfiles, RusotoError<ListConfigurationProfilesError>>;
async fn list_deployment_strategies(
&self,
input: ListDeploymentStrategiesRequest,
) -> Result<DeploymentStrategies, RusotoError<ListDeploymentStrategiesError>>;
async fn list_deployments(
&self,
input: ListDeploymentsRequest,
) -> Result<Deployments, RusotoError<ListDeploymentsError>>;
async fn list_environments(
&self,
input: ListEnvironmentsRequest,
) -> Result<Environments, RusotoError<ListEnvironmentsError>>;
async fn list_hosted_configuration_versions(
&self,
input: ListHostedConfigurationVersionsRequest,
) -> Result<HostedConfigurationVersions, RusotoError<ListHostedConfigurationVersionsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ResourceTags, RusotoError<ListTagsForResourceError>>;
async fn start_deployment(
&self,
input: StartDeploymentRequest,
) -> Result<Deployment, RusotoError<StartDeploymentError>>;
async fn stop_deployment(
&self,
input: StopDeploymentRequest,
) -> Result<Deployment, RusotoError<StopDeploymentError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>>;
async fn update_application(
&self,
input: UpdateApplicationRequest,
) -> Result<Application, RusotoError<UpdateApplicationError>>;
async fn update_configuration_profile(
&self,
input: UpdateConfigurationProfileRequest,
) -> Result<ConfigurationProfile, RusotoError<UpdateConfigurationProfileError>>;
async fn update_deployment_strategy(
&self,
input: UpdateDeploymentStrategyRequest,
) -> Result<DeploymentStrategy, RusotoError<UpdateDeploymentStrategyError>>;
async fn update_environment(
&self,
input: UpdateEnvironmentRequest,
) -> Result<Environment, RusotoError<UpdateEnvironmentError>>;
async fn validate_configuration(
&self,
input: ValidateConfigurationRequest,
) -> Result<(), RusotoError<ValidateConfigurationError>>;
}
#[derive(Clone)]
pub struct AppConfigClient {
client: Client,
region: region::Region,
}
impl AppConfigClient {
pub fn new(region: region::Region) -> AppConfigClient {
AppConfigClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> AppConfigClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
AppConfigClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> AppConfigClient {
AppConfigClient { client, region }
}
}
#[async_trait]
impl AppConfig for AppConfigClient {
#[allow(unused_mut)]
async fn create_application(
&self,
input: CreateApplicationRequest,
) -> Result<Application, RusotoError<CreateApplicationError>> {
let request_uri = "/applications";
let mut request = SignedRequest::new("POST", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<Application, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_configuration_profile(
&self,
input: CreateConfigurationProfileRequest,
) -> Result<ConfigurationProfile, RusotoError<CreateConfigurationProfileError>> {
let request_uri = format!(
"/applications/{application_id}/configurationprofiles",
application_id = input.application_id
);
let mut request = SignedRequest::new("POST", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ConfigurationProfile, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateConfigurationProfileError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_deployment_strategy(
&self,
input: CreateDeploymentStrategyRequest,
) -> Result<DeploymentStrategy, RusotoError<CreateDeploymentStrategyError>> {
let request_uri = "/deploymentstrategies";
let mut request = SignedRequest::new("POST", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeploymentStrategy, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDeploymentStrategyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_environment(
&self,
input: CreateEnvironmentRequest,
) -> Result<Environment, RusotoError<CreateEnvironmentError>> {
let request_uri = format!(
"/applications/{application_id}/environments",
application_id = input.application_id
);
let mut request = SignedRequest::new("POST", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<Environment, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateEnvironmentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_hosted_configuration_version(
&self,
input: CreateHostedConfigurationVersionRequest,
) -> Result<HostedConfigurationVersion, RusotoError<CreateHostedConfigurationVersionError>>
{
let request_uri = format!("/applications/{application_id}/configurationprofiles/{configuration_profile_id}/hostedconfigurationversions", application_id = input.application_id, configuration_profile_id = input.configuration_profile_id);
let mut request = SignedRequest::new("POST", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(input.content.to_owned());
request.set_payload(encoded);
request.add_header("Content-Type", &input.content_type.to_string());
request.add_optional_header("Description", input.description.as_ref());
request.add_optional_header(
"Latest-Version-Number",
input.latest_version_number.as_ref(),
);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let mut result = HostedConfigurationVersion::default();
result.content = Some(response.body);
result.application_id = response.headers.remove("Application-Id");
result.configuration_profile_id = response.headers.remove("Configuration-Profile-Id");
result.content_type = response.headers.remove("Content-Type");
result.description = response.headers.remove("Description");
result.version_number = response
.headers
.remove("Version-Number")
.map(|value| value.parse::<i64>().unwrap());
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateHostedConfigurationVersionError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn delete_application(
&self,
input: DeleteApplicationRequest,
) -> Result<(), RusotoError<DeleteApplicationError>> {
let request_uri = format!(
"/applications/{application_id}",
application_id = input.application_id
);
let mut request = SignedRequest::new("DELETE", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_configuration_profile(
&self,
input: DeleteConfigurationProfileRequest,
) -> Result<(), RusotoError<DeleteConfigurationProfileError>> {
let request_uri = format!(
"/applications/{application_id}/configurationprofiles/{configuration_profile_id}",
application_id = input.application_id,
configuration_profile_id = input.configuration_profile_id
);
let mut request = SignedRequest::new("DELETE", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteConfigurationProfileError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_deployment_strategy(
&self,
input: DeleteDeploymentStrategyRequest,
) -> Result<(), RusotoError<DeleteDeploymentStrategyError>> {
let request_uri = format!(
"/deployementstrategies/{deployment_strategy_id}",
deployment_strategy_id = input.deployment_strategy_id
);
let mut request = SignedRequest::new("DELETE", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteDeploymentStrategyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_environment(
&self,
input: DeleteEnvironmentRequest,
) -> Result<(), RusotoError<DeleteEnvironmentError>> {
let request_uri = format!(
"/applications/{application_id}/environments/{environment_id}",
application_id = input.application_id,
environment_id = input.environment_id
);
let mut request = SignedRequest::new("DELETE", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteEnvironmentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_hosted_configuration_version(
&self,
input: DeleteHostedConfigurationVersionRequest,
) -> Result<(), RusotoError<DeleteHostedConfigurationVersionError>> {
let request_uri = format!("/applications/{application_id}/configurationprofiles/{configuration_profile_id}/hostedconfigurationversions/{version_number}", application_id = input.application_id, configuration_profile_id = input.configuration_profile_id, version_number = input.version_number);
let mut request = SignedRequest::new("DELETE", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteHostedConfigurationVersionError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn get_application(
&self,
input: GetApplicationRequest,
) -> Result<Application, RusotoError<GetApplicationError>> {
let request_uri = format!(
"/applications/{application_id}",
application_id = input.application_id
);
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<Application, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_configuration(
&self,
input: GetConfigurationRequest,
) -> Result<Configuration, RusotoError<GetConfigurationError>> {
let request_uri = format!(
"/applications/{application}/environments/{environment}/configurations/{configuration}",
application = input.application,
configuration = input.configuration,
environment = input.environment
);
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.client_configuration_version {
params.put("client_configuration_version", x);
}
params.put("client_id", &input.client_id);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let mut result = Configuration::default();
result.content = Some(response.body);
result.configuration_version = response.headers.remove("Configuration-Version");
result.content_type = response.headers.remove("Content-Type");
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_configuration_profile(
&self,
input: GetConfigurationProfileRequest,
) -> Result<ConfigurationProfile, RusotoError<GetConfigurationProfileError>> {
let request_uri = format!(
"/applications/{application_id}/configurationprofiles/{configuration_profile_id}",
application_id = input.application_id,
configuration_profile_id = input.configuration_profile_id
);
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ConfigurationProfile, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetConfigurationProfileError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_deployment(
&self,
input: GetDeploymentRequest,
) -> Result<Deployment, RusotoError<GetDeploymentError>> {
let request_uri = format!("/applications/{application_id}/environments/{environment_id}/deployments/{deployment_number}", application_id = input.application_id, deployment_number = input.deployment_number, environment_id = input.environment_id);
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<Deployment, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDeploymentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_deployment_strategy(
&self,
input: GetDeploymentStrategyRequest,
) -> Result<DeploymentStrategy, RusotoError<GetDeploymentStrategyError>> {
let request_uri = format!(
"/deploymentstrategies/{deployment_strategy_id}",
deployment_strategy_id = input.deployment_strategy_id
);
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeploymentStrategy, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDeploymentStrategyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_environment(
&self,
input: GetEnvironmentRequest,
) -> Result<Environment, RusotoError<GetEnvironmentError>> {
let request_uri = format!(
"/applications/{application_id}/environments/{environment_id}",
application_id = input.application_id,
environment_id = input.environment_id
);
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<Environment, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetEnvironmentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_hosted_configuration_version(
&self,
input: GetHostedConfigurationVersionRequest,
) -> Result<HostedConfigurationVersion, RusotoError<GetHostedConfigurationVersionError>> {
let request_uri = format!("/applications/{application_id}/configurationprofiles/{configuration_profile_id}/hostedconfigurationversions/{version_number}", application_id = input.application_id, configuration_profile_id = input.configuration_profile_id, version_number = input.version_number);
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let mut result = HostedConfigurationVersion::default();
result.content = Some(response.body);
result.application_id = response.headers.remove("Application-Id");
result.configuration_profile_id = response.headers.remove("Configuration-Profile-Id");
result.content_type = response.headers.remove("Content-Type");
result.description = response.headers.remove("Description");
result.version_number = response
.headers
.remove("Version-Number")
.map(|value| value.parse::<i64>().unwrap());
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetHostedConfigurationVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_applications(
&self,
input: ListApplicationsRequest,
) -> Result<Applications, RusotoError<ListApplicationsError>> {
let request_uri = "/applications";
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("max_results", x);
}
if let Some(ref x) = input.next_token {
params.put("next_token", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<Applications, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListApplicationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_configuration_profiles(
&self,
input: ListConfigurationProfilesRequest,
) -> Result<ConfigurationProfiles, RusotoError<ListConfigurationProfilesError>> {
let request_uri = format!(
"/applications/{application_id}/configurationprofiles",
application_id = input.application_id
);
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("max_results", x);
}
if let Some(ref x) = input.next_token {
params.put("next_token", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ConfigurationProfiles, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListConfigurationProfilesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_deployment_strategies(
&self,
input: ListDeploymentStrategiesRequest,
) -> Result<DeploymentStrategies, RusotoError<ListDeploymentStrategiesError>> {
let request_uri = "/deploymentstrategies";
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("max_results", x);
}
if let Some(ref x) = input.next_token {
params.put("next_token", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeploymentStrategies, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDeploymentStrategiesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_deployments(
&self,
input: ListDeploymentsRequest,
) -> Result<Deployments, RusotoError<ListDeploymentsError>> {
let request_uri = format!(
"/applications/{application_id}/environments/{environment_id}/deployments",
application_id = input.application_id,
environment_id = input.environment_id
);
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("max_results", x);
}
if let Some(ref x) = input.next_token {
params.put("next_token", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<Deployments, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDeploymentsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_environments(
&self,
input: ListEnvironmentsRequest,
) -> Result<Environments, RusotoError<ListEnvironmentsError>> {
let request_uri = format!(
"/applications/{application_id}/environments",
application_id = input.application_id
);
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("max_results", x);
}
if let Some(ref x) = input.next_token {
params.put("next_token", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<Environments, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListEnvironmentsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_hosted_configuration_versions(
&self,
input: ListHostedConfigurationVersionsRequest,
) -> Result<HostedConfigurationVersions, RusotoError<ListHostedConfigurationVersionsError>>
{
let request_uri = format!("/applications/{application_id}/configurationprofiles/{configuration_profile_id}/hostedconfigurationversions", application_id = input.application_id, configuration_profile_id = input.configuration_profile_id);
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("max_results", x);
}
if let Some(ref x) = input.next_token {
params.put("next_token", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<HostedConfigurationVersions, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListHostedConfigurationVersionsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ResourceTags, RusotoError<ListTagsForResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<ResourceTags, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_deployment(
&self,
input: StartDeploymentRequest,
) -> Result<Deployment, RusotoError<StartDeploymentError>> {
let request_uri = format!(
"/applications/{application_id}/environments/{environment_id}/deployments",
application_id = input.application_id,
environment_id = input.environment_id
);
let mut request = SignedRequest::new("POST", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<Deployment, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartDeploymentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn stop_deployment(
&self,
input: StopDeploymentRequest,
) -> Result<Deployment, RusotoError<StopDeploymentError>> {
let request_uri = format!("/applications/{application_id}/environments/{environment_id}/deployments/{deployment_number}", application_id = input.application_id, deployment_number = input.deployment_number, environment_id = input.environment_id);
let mut request = SignedRequest::new("DELETE", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<Deployment, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StopDeploymentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
for item in input.tag_keys.iter() {
params.put("tagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_application(
&self,
input: UpdateApplicationRequest,
) -> Result<Application, RusotoError<UpdateApplicationError>> {
let request_uri = format!(
"/applications/{application_id}",
application_id = input.application_id
);
let mut request = SignedRequest::new("PATCH", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<Application, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_configuration_profile(
&self,
input: UpdateConfigurationProfileRequest,
) -> Result<ConfigurationProfile, RusotoError<UpdateConfigurationProfileError>> {
let request_uri = format!(
"/applications/{application_id}/configurationprofiles/{configuration_profile_id}",
application_id = input.application_id,
configuration_profile_id = input.configuration_profile_id
);
let mut request = SignedRequest::new("PATCH", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ConfigurationProfile, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateConfigurationProfileError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_deployment_strategy(
&self,
input: UpdateDeploymentStrategyRequest,
) -> Result<DeploymentStrategy, RusotoError<UpdateDeploymentStrategyError>> {
let request_uri = format!(
"/deploymentstrategies/{deployment_strategy_id}",
deployment_strategy_id = input.deployment_strategy_id
);
let mut request = SignedRequest::new("PATCH", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeploymentStrategy, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateDeploymentStrategyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_environment(
&self,
input: UpdateEnvironmentRequest,
) -> Result<Environment, RusotoError<UpdateEnvironmentError>> {
let request_uri = format!(
"/applications/{application_id}/environments/{environment_id}",
application_id = input.application_id,
environment_id = input.environment_id
);
let mut request = SignedRequest::new("PATCH", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<Environment, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateEnvironmentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn validate_configuration(
&self,
input: ValidateConfigurationRequest,
) -> Result<(), RusotoError<ValidateConfigurationError>> {
let request_uri = format!("/applications/{application_id}/configurationprofiles/{configuration_profile_id}/validators", application_id = input.application_id, configuration_profile_id = input.configuration_profile_id);
let mut request = SignedRequest::new("POST", "appconfig", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("configuration_version", &input.configuration_version);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ValidateConfigurationError::from_response(response))
}
}
}