use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl CodeDeployClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "codedeploy", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddTagsToOnPremisesInstancesInput {
#[serde(rename = "instanceNames")]
pub instance_names: Vec<String>,
#[serde(rename = "tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Alarm {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AlarmConfiguration {
#[serde(rename = "alarms")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alarms: Option<Vec<Alarm>>,
#[serde(rename = "enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "ignorePollAlarmFailure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ignore_poll_alarm_failure: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AppSpecContent {
#[serde(rename = "content")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content: Option<String>,
#[serde(rename = "sha256")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sha_256: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApplicationInfo {
#[serde(rename = "applicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "applicationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_name: Option<String>,
#[serde(rename = "computePlatform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute_platform: Option<String>,
#[serde(rename = "createTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time: Option<f64>,
#[serde(rename = "gitHubAccountName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub git_hub_account_name: Option<String>,
#[serde(rename = "linkedToGitHub")]
#[serde(skip_serializing_if = "Option::is_none")]
pub linked_to_git_hub: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AutoRollbackConfiguration {
#[serde(rename = "enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "events")]
#[serde(skip_serializing_if = "Option::is_none")]
pub events: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AutoScalingGroup {
#[serde(rename = "hook")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hook: 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 BatchGetApplicationRevisionsInput {
#[serde(rename = "applicationName")]
pub application_name: String,
#[serde(rename = "revisions")]
pub revisions: Vec<RevisionLocation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetApplicationRevisionsOutput {
#[serde(rename = "applicationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_name: Option<String>,
#[serde(rename = "errorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "revisions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revisions: Option<Vec<RevisionInfo>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetApplicationsInput {
#[serde(rename = "applicationNames")]
pub application_names: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetApplicationsOutput {
#[serde(rename = "applicationsInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub applications_info: Option<Vec<ApplicationInfo>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetDeploymentGroupsInput {
#[serde(rename = "applicationName")]
pub application_name: String,
#[serde(rename = "deploymentGroupNames")]
pub deployment_group_names: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetDeploymentGroupsOutput {
#[serde(rename = "deploymentGroupsInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_groups_info: Option<Vec<DeploymentGroupInfo>>,
#[serde(rename = "errorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetDeploymentInstancesInput {
#[serde(rename = "deploymentId")]
pub deployment_id: String,
#[serde(rename = "instanceIds")]
pub instance_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetDeploymentInstancesOutput {
#[serde(rename = "errorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "instancesSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instances_summary: Option<Vec<InstanceSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetDeploymentTargetsInput {
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "targetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetDeploymentTargetsOutput {
#[serde(rename = "deploymentTargets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_targets: Option<Vec<DeploymentTarget>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetDeploymentsInput {
#[serde(rename = "deploymentIds")]
pub deployment_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetDeploymentsOutput {
#[serde(rename = "deploymentsInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployments_info: Option<Vec<DeploymentInfo>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetOnPremisesInstancesInput {
#[serde(rename = "instanceNames")]
pub instance_names: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetOnPremisesInstancesOutput {
#[serde(rename = "instanceInfos")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_infos: Option<Vec<InstanceInfo>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct BlueGreenDeploymentConfiguration {
#[serde(rename = "deploymentReadyOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_ready_option: Option<DeploymentReadyOption>,
#[serde(rename = "greenFleetProvisioningOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub green_fleet_provisioning_option: Option<GreenFleetProvisioningOption>,
#[serde(rename = "terminateBlueInstancesOnDeploymentSuccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub terminate_blue_instances_on_deployment_success: Option<BlueInstanceTerminationOption>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct BlueInstanceTerminationOption {
#[serde(rename = "action")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action: Option<String>,
#[serde(rename = "terminationWaitTimeInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub termination_wait_time_in_minutes: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CloudFormationTarget {
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "lifecycleEvents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_events: Option<Vec<LifecycleEvent>>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "targetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_id: Option<String>,
#[serde(rename = "targetVersionWeight")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_version_weight: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ContinueDeploymentInput {
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "deploymentWaitType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_wait_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateApplicationInput {
#[serde(rename = "applicationName")]
pub application_name: String,
#[serde(rename = "computePlatform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute_platform: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateApplicationOutput {
#[serde(rename = "applicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDeploymentConfigInput {
#[serde(rename = "computePlatform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute_platform: Option<String>,
#[serde(rename = "deploymentConfigName")]
pub deployment_config_name: String,
#[serde(rename = "minimumHealthyHosts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum_healthy_hosts: Option<MinimumHealthyHosts>,
#[serde(rename = "trafficRoutingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub traffic_routing_config: Option<TrafficRoutingConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDeploymentConfigOutput {
#[serde(rename = "deploymentConfigId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDeploymentGroupInput {
#[serde(rename = "alarmConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alarm_configuration: Option<AlarmConfiguration>,
#[serde(rename = "applicationName")]
pub application_name: String,
#[serde(rename = "autoRollbackConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_rollback_configuration: Option<AutoRollbackConfiguration>,
#[serde(rename = "autoScalingGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_groups: Option<Vec<String>>,
#[serde(rename = "blueGreenDeploymentConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blue_green_deployment_configuration: Option<BlueGreenDeploymentConfiguration>,
#[serde(rename = "deploymentConfigName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config_name: Option<String>,
#[serde(rename = "deploymentGroupName")]
pub deployment_group_name: String,
#[serde(rename = "deploymentStyle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_style: Option<DeploymentStyle>,
#[serde(rename = "ec2TagFilters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_tag_filters: Option<Vec<EC2TagFilter>>,
#[serde(rename = "ec2TagSet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_tag_set: Option<EC2TagSet>,
#[serde(rename = "ecsServices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ecs_services: Option<Vec<ECSService>>,
#[serde(rename = "loadBalancerInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub load_balancer_info: Option<LoadBalancerInfo>,
#[serde(rename = "onPremisesInstanceTagFilters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub on_premises_instance_tag_filters: Option<Vec<TagFilter>>,
#[serde(rename = "onPremisesTagSet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub on_premises_tag_set: Option<OnPremisesTagSet>,
#[serde(rename = "serviceRoleArn")]
pub service_role_arn: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "triggerConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trigger_configurations: Option<Vec<TriggerConfig>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDeploymentGroupOutput {
#[serde(rename = "deploymentGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_group_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDeploymentInput {
#[serde(rename = "applicationName")]
pub application_name: String,
#[serde(rename = "autoRollbackConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_rollback_configuration: Option<AutoRollbackConfiguration>,
#[serde(rename = "deploymentConfigName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config_name: Option<String>,
#[serde(rename = "deploymentGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_group_name: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "fileExistsBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_exists_behavior: Option<String>,
#[serde(rename = "ignoreApplicationStopFailures")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ignore_application_stop_failures: Option<bool>,
#[serde(rename = "revision")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision: Option<RevisionLocation>,
#[serde(rename = "targetInstances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_instances: Option<TargetInstances>,
#[serde(rename = "updateOutdatedInstancesOnly")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_outdated_instances_only: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDeploymentOutput {
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApplicationInput {
#[serde(rename = "applicationName")]
pub application_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDeploymentConfigInput {
#[serde(rename = "deploymentConfigName")]
pub deployment_config_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDeploymentGroupInput {
#[serde(rename = "applicationName")]
pub application_name: String,
#[serde(rename = "deploymentGroupName")]
pub deployment_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDeploymentGroupOutput {
#[serde(rename = "hooksNotCleanedUp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hooks_not_cleaned_up: Option<Vec<AutoScalingGroup>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteGitHubAccountTokenInput {
#[serde(rename = "tokenName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteGitHubAccountTokenOutput {
#[serde(rename = "tokenName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteResourcesByExternalIdInput {
#[serde(rename = "externalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteResourcesByExternalIdOutput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeploymentConfigInfo {
#[serde(rename = "computePlatform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute_platform: Option<String>,
#[serde(rename = "createTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time: Option<f64>,
#[serde(rename = "deploymentConfigId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config_id: Option<String>,
#[serde(rename = "deploymentConfigName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config_name: Option<String>,
#[serde(rename = "minimumHealthyHosts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum_healthy_hosts: Option<MinimumHealthyHosts>,
#[serde(rename = "trafficRoutingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub traffic_routing_config: Option<TrafficRoutingConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeploymentGroupInfo {
#[serde(rename = "alarmConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alarm_configuration: Option<AlarmConfiguration>,
#[serde(rename = "applicationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_name: Option<String>,
#[serde(rename = "autoRollbackConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_rollback_configuration: Option<AutoRollbackConfiguration>,
#[serde(rename = "autoScalingGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_groups: Option<Vec<AutoScalingGroup>>,
#[serde(rename = "blueGreenDeploymentConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blue_green_deployment_configuration: Option<BlueGreenDeploymentConfiguration>,
#[serde(rename = "computePlatform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute_platform: Option<String>,
#[serde(rename = "deploymentConfigName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config_name: Option<String>,
#[serde(rename = "deploymentGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_group_id: Option<String>,
#[serde(rename = "deploymentGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_group_name: Option<String>,
#[serde(rename = "deploymentStyle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_style: Option<DeploymentStyle>,
#[serde(rename = "ec2TagFilters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_tag_filters: Option<Vec<EC2TagFilter>>,
#[serde(rename = "ec2TagSet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_tag_set: Option<EC2TagSet>,
#[serde(rename = "ecsServices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ecs_services: Option<Vec<ECSService>>,
#[serde(rename = "lastAttemptedDeployment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_attempted_deployment: Option<LastDeploymentInfo>,
#[serde(rename = "lastSuccessfulDeployment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_successful_deployment: Option<LastDeploymentInfo>,
#[serde(rename = "loadBalancerInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub load_balancer_info: Option<LoadBalancerInfo>,
#[serde(rename = "onPremisesInstanceTagFilters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub on_premises_instance_tag_filters: Option<Vec<TagFilter>>,
#[serde(rename = "onPremisesTagSet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub on_premises_tag_set: Option<OnPremisesTagSet>,
#[serde(rename = "serviceRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_role_arn: Option<String>,
#[serde(rename = "targetRevision")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_revision: Option<RevisionLocation>,
#[serde(rename = "triggerConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trigger_configurations: Option<Vec<TriggerConfig>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeploymentInfo {
#[serde(rename = "additionalDeploymentStatusInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_deployment_status_info: Option<String>,
#[serde(rename = "applicationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_name: Option<String>,
#[serde(rename = "autoRollbackConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_rollback_configuration: Option<AutoRollbackConfiguration>,
#[serde(rename = "blueGreenDeploymentConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blue_green_deployment_configuration: Option<BlueGreenDeploymentConfiguration>,
#[serde(rename = "completeTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub complete_time: Option<f64>,
#[serde(rename = "computePlatform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute_platform: Option<String>,
#[serde(rename = "createTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time: Option<f64>,
#[serde(rename = "creator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator: Option<String>,
#[serde(rename = "deploymentConfigName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config_name: Option<String>,
#[serde(rename = "deploymentGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_group_name: Option<String>,
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "deploymentOverview")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_overview: Option<DeploymentOverview>,
#[serde(rename = "deploymentStatusMessages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_status_messages: Option<Vec<String>>,
#[serde(rename = "deploymentStyle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_style: Option<DeploymentStyle>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "errorInformation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_information: Option<ErrorInformation>,
#[serde(rename = "externalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external_id: Option<String>,
#[serde(rename = "fileExistsBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_exists_behavior: Option<String>,
#[serde(rename = "ignoreApplicationStopFailures")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ignore_application_stop_failures: Option<bool>,
#[serde(rename = "instanceTerminationWaitTimeStarted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_termination_wait_time_started: Option<bool>,
#[serde(rename = "loadBalancerInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub load_balancer_info: Option<LoadBalancerInfo>,
#[serde(rename = "previousRevision")]
#[serde(skip_serializing_if = "Option::is_none")]
pub previous_revision: Option<RevisionLocation>,
#[serde(rename = "revision")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision: Option<RevisionLocation>,
#[serde(rename = "rollbackInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rollback_info: Option<RollbackInfo>,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "targetInstances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_instances: Option<TargetInstances>,
#[serde(rename = "updateOutdatedInstancesOnly")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_outdated_instances_only: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeploymentOverview {
#[serde(rename = "Failed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed: Option<i64>,
#[serde(rename = "InProgress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub in_progress: Option<i64>,
#[serde(rename = "Pending")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pending: Option<i64>,
#[serde(rename = "Ready")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ready: Option<i64>,
#[serde(rename = "Skipped")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skipped: Option<i64>,
#[serde(rename = "Succeeded")]
#[serde(skip_serializing_if = "Option::is_none")]
pub succeeded: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeploymentReadyOption {
#[serde(rename = "actionOnTimeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action_on_timeout: Option<String>,
#[serde(rename = "waitTimeInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub wait_time_in_minutes: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeploymentStyle {
#[serde(rename = "deploymentOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_option: Option<String>,
#[serde(rename = "deploymentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeploymentTarget {
#[serde(rename = "cloudFormationTarget")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_formation_target: Option<CloudFormationTarget>,
#[serde(rename = "deploymentTargetType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_target_type: Option<String>,
#[serde(rename = "ecsTarget")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ecs_target: Option<ECSTarget>,
#[serde(rename = "instanceTarget")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_target: Option<InstanceTarget>,
#[serde(rename = "lambdaTarget")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_target: Option<LambdaTarget>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeregisterOnPremisesInstanceInput {
#[serde(rename = "instanceName")]
pub instance_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Diagnostics {
#[serde(rename = "errorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "logTail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_tail: Option<String>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "scriptName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub script_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct EC2TagFilter {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct EC2TagSet {
#[serde(rename = "ec2TagSetList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_tag_set_list: Option<Vec<Vec<EC2TagFilter>>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ECSService {
#[serde(rename = "clusterName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cluster_name: Option<String>,
#[serde(rename = "serviceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ECSTarget {
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "lifecycleEvents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_events: Option<Vec<LifecycleEvent>>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "targetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_arn: Option<String>,
#[serde(rename = "targetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_id: Option<String>,
#[serde(rename = "taskSetsInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_sets_info: Option<Vec<ECSTaskSet>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ECSTaskSet {
#[serde(rename = "desiredCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub desired_count: Option<i64>,
#[serde(rename = "identifer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identifer: Option<String>,
#[serde(rename = "pendingCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pending_count: Option<i64>,
#[serde(rename = "runningCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub running_count: Option<i64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "targetGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_group: Option<TargetGroupInfo>,
#[serde(rename = "taskSetLabel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_set_label: Option<String>,
#[serde(rename = "trafficWeight")]
#[serde(skip_serializing_if = "Option::is_none")]
pub traffic_weight: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ELBInfo {
#[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 ErrorInformation {
#[serde(rename = "code")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GenericRevisionInfo {
#[serde(rename = "deploymentGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_groups: Option<Vec<String>>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "firstUsedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub first_used_time: Option<f64>,
#[serde(rename = "lastUsedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_used_time: Option<f64>,
#[serde(rename = "registerTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub register_time: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetApplicationInput {
#[serde(rename = "applicationName")]
pub application_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetApplicationOutput {
#[serde(rename = "application")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application: Option<ApplicationInfo>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetApplicationRevisionInput {
#[serde(rename = "applicationName")]
pub application_name: String,
#[serde(rename = "revision")]
pub revision: RevisionLocation,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetApplicationRevisionOutput {
#[serde(rename = "applicationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_name: Option<String>,
#[serde(rename = "revision")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision: Option<RevisionLocation>,
#[serde(rename = "revisionInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_info: Option<GenericRevisionInfo>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeploymentConfigInput {
#[serde(rename = "deploymentConfigName")]
pub deployment_config_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeploymentConfigOutput {
#[serde(rename = "deploymentConfigInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config_info: Option<DeploymentConfigInfo>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeploymentGroupInput {
#[serde(rename = "applicationName")]
pub application_name: String,
#[serde(rename = "deploymentGroupName")]
pub deployment_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeploymentGroupOutput {
#[serde(rename = "deploymentGroupInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_group_info: Option<DeploymentGroupInfo>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeploymentInput {
#[serde(rename = "deploymentId")]
pub deployment_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeploymentInstanceInput {
#[serde(rename = "deploymentId")]
pub deployment_id: String,
#[serde(rename = "instanceId")]
pub instance_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeploymentInstanceOutput {
#[serde(rename = "instanceSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_summary: Option<InstanceSummary>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeploymentOutput {
#[serde(rename = "deploymentInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_info: Option<DeploymentInfo>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeploymentTargetInput {
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "targetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeploymentTargetOutput {
#[serde(rename = "deploymentTarget")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_target: Option<DeploymentTarget>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetOnPremisesInstanceInput {
#[serde(rename = "instanceName")]
pub instance_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetOnPremisesInstanceOutput {
#[serde(rename = "instanceInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_info: Option<InstanceInfo>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct GitHubLocation {
#[serde(rename = "commitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_id: Option<String>,
#[serde(rename = "repository")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct GreenFleetProvisioningOption {
#[serde(rename = "action")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceInfo {
#[serde(rename = "deregisterTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deregister_time: Option<f64>,
#[serde(rename = "iamSessionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_session_arn: Option<String>,
#[serde(rename = "iamUserArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_user_arn: Option<String>,
#[serde(rename = "instanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_arn: Option<String>,
#[serde(rename = "instanceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_name: Option<String>,
#[serde(rename = "registerTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub register_time: Option<f64>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceSummary {
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "instanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "instanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "lifecycleEvents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_events: Option<Vec<LifecycleEvent>>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceTarget {
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "instanceLabel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_label: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "lifecycleEvents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_events: Option<Vec<LifecycleEvent>>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "targetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_arn: Option<String>,
#[serde(rename = "targetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LambdaFunctionInfo {
#[serde(rename = "currentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_version: Option<String>,
#[serde(rename = "functionAlias")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_alias: Option<String>,
#[serde(rename = "functionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_name: Option<String>,
#[serde(rename = "targetVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_version: Option<String>,
#[serde(rename = "targetVersionWeight")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_version_weight: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LambdaTarget {
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "lambdaFunctionInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_function_info: Option<LambdaFunctionInfo>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "lifecycleEvents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_events: Option<Vec<LifecycleEvent>>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "targetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_arn: Option<String>,
#[serde(rename = "targetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LastDeploymentInfo {
#[serde(rename = "createTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time: Option<f64>,
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "endTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LifecycleEvent {
#[serde(rename = "diagnostics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub diagnostics: Option<Diagnostics>,
#[serde(rename = "endTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "lifecycleEventName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_event_name: Option<String>,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListApplicationRevisionsInput {
#[serde(rename = "applicationName")]
pub application_name: String,
#[serde(rename = "deployed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployed: Option<String>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "s3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_bucket: Option<String>,
#[serde(rename = "s3KeyPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_key_prefix: Option<String>,
#[serde(rename = "sortBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sort_by: Option<String>,
#[serde(rename = "sortOrder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sort_order: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListApplicationRevisionsOutput {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "revisions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revisions: Option<Vec<RevisionLocation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListApplicationsInput {
#[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 ListApplicationsOutput {
#[serde(rename = "applications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub applications: Option<Vec<String>>,
#[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 ListDeploymentConfigsInput {
#[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 ListDeploymentConfigsOutput {
#[serde(rename = "deploymentConfigsList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_configs_list: Option<Vec<String>>,
#[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 ListDeploymentGroupsInput {
#[serde(rename = "applicationName")]
pub application_name: String,
#[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 ListDeploymentGroupsOutput {
#[serde(rename = "applicationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_name: Option<String>,
#[serde(rename = "deploymentGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_groups: Option<Vec<String>>,
#[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 ListDeploymentInstancesInput {
#[serde(rename = "deploymentId")]
pub deployment_id: String,
#[serde(rename = "instanceStatusFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_status_filter: Option<Vec<String>>,
#[serde(rename = "instanceTypeFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type_filter: Option<Vec<String>>,
#[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 ListDeploymentInstancesOutput {
#[serde(rename = "instancesList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instances_list: Option<Vec<String>>,
#[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 ListDeploymentTargetsInput {
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "targetFilters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_filters: Option<::std::collections::HashMap<String, Vec<String>>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDeploymentTargetsOutput {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "targetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDeploymentsInput {
#[serde(rename = "applicationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_name: Option<String>,
#[serde(rename = "createTimeRange")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time_range: Option<TimeRange>,
#[serde(rename = "deploymentGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_group_name: Option<String>,
#[serde(rename = "externalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external_id: Option<String>,
#[serde(rename = "includeOnlyStatuses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_only_statuses: Option<Vec<String>>,
#[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 ListDeploymentsOutput {
#[serde(rename = "deployments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployments: Option<Vec<String>>,
#[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 ListGitHubAccountTokenNamesInput {
#[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 ListGitHubAccountTokenNamesOutput {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "tokenNameList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_name_list: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListOnPremisesInstancesInput {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "registrationStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registration_status: Option<String>,
#[serde(rename = "tagFilters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_filters: Option<Vec<TagFilter>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListOnPremisesInstancesOutput {
#[serde(rename = "instanceNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_names: Option<Vec<String>>,
#[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 ListTagsForResourceInput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LoadBalancerInfo {
#[serde(rename = "elbInfoList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elb_info_list: Option<Vec<ELBInfo>>,
#[serde(rename = "targetGroupInfoList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_group_info_list: Option<Vec<TargetGroupInfo>>,
#[serde(rename = "targetGroupPairInfoList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_group_pair_info_list: Option<Vec<TargetGroupPairInfo>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MinimumHealthyHosts {
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OnPremisesTagSet {
#[serde(rename = "onPremisesTagSetList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub on_premises_tag_set_list: Option<Vec<Vec<TagFilter>>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutLifecycleEventHookExecutionStatusInput {
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "lifecycleEventHookExecutionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_event_hook_execution_id: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutLifecycleEventHookExecutionStatusOutput {
#[serde(rename = "lifecycleEventHookExecutionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_event_hook_execution_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RawString {
#[serde(rename = "content")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content: Option<String>,
#[serde(rename = "sha256")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sha_256: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RegisterApplicationRevisionInput {
#[serde(rename = "applicationName")]
pub application_name: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "revision")]
pub revision: RevisionLocation,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RegisterOnPremisesInstanceInput {
#[serde(rename = "iamSessionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_session_arn: Option<String>,
#[serde(rename = "iamUserArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_user_arn: Option<String>,
#[serde(rename = "instanceName")]
pub instance_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemoveTagsFromOnPremisesInstancesInput {
#[serde(rename = "instanceNames")]
pub instance_names: Vec<String>,
#[serde(rename = "tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RevisionInfo {
#[serde(rename = "genericRevisionInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub generic_revision_info: Option<GenericRevisionInfo>,
#[serde(rename = "revisionLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_location: Option<RevisionLocation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RevisionLocation {
#[serde(rename = "appSpecContent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_spec_content: Option<AppSpecContent>,
#[serde(rename = "gitHubLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub git_hub_location: Option<GitHubLocation>,
#[serde(rename = "revisionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_type: Option<String>,
#[serde(rename = "s3Location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_location: Option<S3Location>,
#[serde(rename = "string")]
#[serde(skip_serializing_if = "Option::is_none")]
pub string: Option<RawString>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RollbackInfo {
#[serde(rename = "rollbackDeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rollback_deployment_id: Option<String>,
#[serde(rename = "rollbackMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rollback_message: Option<String>,
#[serde(rename = "rollbackTriggeringDeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rollback_triggering_deployment_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct S3Location {
#[serde(rename = "bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket: Option<String>,
#[serde(rename = "bundleType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundle_type: Option<String>,
#[serde(rename = "eTag")]
#[serde(skip_serializing_if = "Option::is_none")]
pub e_tag: Option<String>,
#[serde(rename = "key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SkipWaitTimeForInstanceTerminationInput {
#[serde(rename = "deploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopDeploymentInput {
#[serde(rename = "autoRollbackEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_rollback_enabled: Option<bool>,
#[serde(rename = "deploymentId")]
pub deployment_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopDeploymentOutput {
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "statusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TagFilter {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceInput {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceOutput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TargetGroupInfo {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TargetGroupPairInfo {
#[serde(rename = "prodTrafficRoute")]
#[serde(skip_serializing_if = "Option::is_none")]
pub prod_traffic_route: Option<TrafficRoute>,
#[serde(rename = "targetGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_groups: Option<Vec<TargetGroupInfo>>,
#[serde(rename = "testTrafficRoute")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_traffic_route: Option<TrafficRoute>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TargetInstances {
#[serde(rename = "autoScalingGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_groups: Option<Vec<String>>,
#[serde(rename = "ec2TagSet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_tag_set: Option<EC2TagSet>,
#[serde(rename = "tagFilters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_filters: Option<Vec<EC2TagFilter>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TimeBasedCanary {
#[serde(rename = "canaryInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub canary_interval: Option<i64>,
#[serde(rename = "canaryPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub canary_percentage: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TimeBasedLinear {
#[serde(rename = "linearInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub linear_interval: Option<i64>,
#[serde(rename = "linearPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub linear_percentage: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TimeRange {
#[serde(rename = "end")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end: Option<f64>,
#[serde(rename = "start")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TrafficRoute {
#[serde(rename = "listenerArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub listener_arns: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TrafficRoutingConfig {
#[serde(rename = "timeBasedCanary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub time_based_canary: Option<TimeBasedCanary>,
#[serde(rename = "timeBasedLinear")]
#[serde(skip_serializing_if = "Option::is_none")]
pub time_based_linear: Option<TimeBasedLinear>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TriggerConfig {
#[serde(rename = "triggerEvents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trigger_events: Option<Vec<String>>,
#[serde(rename = "triggerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trigger_name: Option<String>,
#[serde(rename = "triggerTargetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trigger_target_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceInput {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateApplicationInput {
#[serde(rename = "applicationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_name: Option<String>,
#[serde(rename = "newApplicationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub new_application_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDeploymentGroupInput {
#[serde(rename = "alarmConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alarm_configuration: Option<AlarmConfiguration>,
#[serde(rename = "applicationName")]
pub application_name: String,
#[serde(rename = "autoRollbackConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_rollback_configuration: Option<AutoRollbackConfiguration>,
#[serde(rename = "autoScalingGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_groups: Option<Vec<String>>,
#[serde(rename = "blueGreenDeploymentConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blue_green_deployment_configuration: Option<BlueGreenDeploymentConfiguration>,
#[serde(rename = "currentDeploymentGroupName")]
pub current_deployment_group_name: String,
#[serde(rename = "deploymentConfigName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config_name: Option<String>,
#[serde(rename = "deploymentStyle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_style: Option<DeploymentStyle>,
#[serde(rename = "ec2TagFilters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_tag_filters: Option<Vec<EC2TagFilter>>,
#[serde(rename = "ec2TagSet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_tag_set: Option<EC2TagSet>,
#[serde(rename = "ecsServices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ecs_services: Option<Vec<ECSService>>,
#[serde(rename = "loadBalancerInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub load_balancer_info: Option<LoadBalancerInfo>,
#[serde(rename = "newDeploymentGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub new_deployment_group_name: Option<String>,
#[serde(rename = "onPremisesInstanceTagFilters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub on_premises_instance_tag_filters: Option<Vec<TagFilter>>,
#[serde(rename = "onPremisesTagSet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub on_premises_tag_set: Option<OnPremisesTagSet>,
#[serde(rename = "serviceRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_role_arn: Option<String>,
#[serde(rename = "triggerConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trigger_configurations: Option<Vec<TriggerConfig>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDeploymentGroupOutput {
#[serde(rename = "hooksNotCleanedUp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hooks_not_cleaned_up: Option<Vec<AutoScalingGroup>>,
}
#[derive(Debug, PartialEq)]
pub enum AddTagsToOnPremisesInstancesError {
InstanceLimitExceeded(String),
InstanceNameRequired(String),
InstanceNotRegistered(String),
InvalidInstanceName(String),
InvalidTag(String),
TagLimitExceeded(String),
TagRequired(String),
}
impl AddTagsToOnPremisesInstancesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AddTagsToOnPremisesInstancesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InstanceLimitExceededException" => {
return RusotoError::Service(
AddTagsToOnPremisesInstancesError::InstanceLimitExceeded(err.msg),
)
}
"InstanceNameRequiredException" => {
return RusotoError::Service(
AddTagsToOnPremisesInstancesError::InstanceNameRequired(err.msg),
)
}
"InstanceNotRegisteredException" => {
return RusotoError::Service(
AddTagsToOnPremisesInstancesError::InstanceNotRegistered(err.msg),
)
}
"InvalidInstanceNameException" => {
return RusotoError::Service(
AddTagsToOnPremisesInstancesError::InvalidInstanceName(err.msg),
)
}
"InvalidTagException" => {
return RusotoError::Service(AddTagsToOnPremisesInstancesError::InvalidTag(
err.msg,
))
}
"TagLimitExceededException" => {
return RusotoError::Service(
AddTagsToOnPremisesInstancesError::TagLimitExceeded(err.msg),
)
}
"TagRequiredException" => {
return RusotoError::Service(AddTagsToOnPremisesInstancesError::TagRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddTagsToOnPremisesInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddTagsToOnPremisesInstancesError::InstanceLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
AddTagsToOnPremisesInstancesError::InstanceNameRequired(ref cause) => {
write!(f, "{}", cause)
}
AddTagsToOnPremisesInstancesError::InstanceNotRegistered(ref cause) => {
write!(f, "{}", cause)
}
AddTagsToOnPremisesInstancesError::InvalidInstanceName(ref cause) => {
write!(f, "{}", cause)
}
AddTagsToOnPremisesInstancesError::InvalidTag(ref cause) => write!(f, "{}", cause),
AddTagsToOnPremisesInstancesError::TagLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
AddTagsToOnPremisesInstancesError::TagRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddTagsToOnPremisesInstancesError {}
#[derive(Debug, PartialEq)]
pub enum BatchGetApplicationRevisionsError {
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
BatchLimitExceeded(String),
InvalidApplicationName(String),
InvalidRevision(String),
RevisionRequired(String),
}
impl BatchGetApplicationRevisionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<BatchGetApplicationRevisionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationDoesNotExistException" => {
return RusotoError::Service(
BatchGetApplicationRevisionsError::ApplicationDoesNotExist(err.msg),
)
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(
BatchGetApplicationRevisionsError::ApplicationNameRequired(err.msg),
)
}
"BatchLimitExceededException" => {
return RusotoError::Service(
BatchGetApplicationRevisionsError::BatchLimitExceeded(err.msg),
)
}
"InvalidApplicationNameException" => {
return RusotoError::Service(
BatchGetApplicationRevisionsError::InvalidApplicationName(err.msg),
)
}
"InvalidRevisionException" => {
return RusotoError::Service(
BatchGetApplicationRevisionsError::InvalidRevision(err.msg),
)
}
"RevisionRequiredException" => {
return RusotoError::Service(
BatchGetApplicationRevisionsError::RevisionRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGetApplicationRevisionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGetApplicationRevisionsError::ApplicationDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
BatchGetApplicationRevisionsError::ApplicationNameRequired(ref cause) => {
write!(f, "{}", cause)
}
BatchGetApplicationRevisionsError::BatchLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
BatchGetApplicationRevisionsError::InvalidApplicationName(ref cause) => {
write!(f, "{}", cause)
}
BatchGetApplicationRevisionsError::InvalidRevision(ref cause) => write!(f, "{}", cause),
BatchGetApplicationRevisionsError::RevisionRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for BatchGetApplicationRevisionsError {}
#[derive(Debug, PartialEq)]
pub enum BatchGetApplicationsError {
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
BatchLimitExceeded(String),
InvalidApplicationName(String),
}
impl BatchGetApplicationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchGetApplicationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationDoesNotExistException" => {
return RusotoError::Service(
BatchGetApplicationsError::ApplicationDoesNotExist(err.msg),
)
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(
BatchGetApplicationsError::ApplicationNameRequired(err.msg),
)
}
"BatchLimitExceededException" => {
return RusotoError::Service(BatchGetApplicationsError::BatchLimitExceeded(
err.msg,
))
}
"InvalidApplicationNameException" => {
return RusotoError::Service(BatchGetApplicationsError::InvalidApplicationName(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGetApplicationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGetApplicationsError::ApplicationDoesNotExist(ref cause) => write!(f, "{}", cause),
BatchGetApplicationsError::ApplicationNameRequired(ref cause) => write!(f, "{}", cause),
BatchGetApplicationsError::BatchLimitExceeded(ref cause) => write!(f, "{}", cause),
BatchGetApplicationsError::InvalidApplicationName(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchGetApplicationsError {}
#[derive(Debug, PartialEq)]
pub enum BatchGetDeploymentGroupsError {
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
BatchLimitExceeded(String),
DeploymentConfigDoesNotExist(String),
DeploymentGroupNameRequired(String),
InvalidApplicationName(String),
InvalidDeploymentGroupName(String),
}
impl BatchGetDeploymentGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchGetDeploymentGroupsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationDoesNotExistException" => {
return RusotoError::Service(
BatchGetDeploymentGroupsError::ApplicationDoesNotExist(err.msg),
)
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(
BatchGetDeploymentGroupsError::ApplicationNameRequired(err.msg),
)
}
"BatchLimitExceededException" => {
return RusotoError::Service(BatchGetDeploymentGroupsError::BatchLimitExceeded(
err.msg,
))
}
"DeploymentConfigDoesNotExistException" => {
return RusotoError::Service(
BatchGetDeploymentGroupsError::DeploymentConfigDoesNotExist(err.msg),
)
}
"DeploymentGroupNameRequiredException" => {
return RusotoError::Service(
BatchGetDeploymentGroupsError::DeploymentGroupNameRequired(err.msg),
)
}
"InvalidApplicationNameException" => {
return RusotoError::Service(
BatchGetDeploymentGroupsError::InvalidApplicationName(err.msg),
)
}
"InvalidDeploymentGroupNameException" => {
return RusotoError::Service(
BatchGetDeploymentGroupsError::InvalidDeploymentGroupName(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGetDeploymentGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGetDeploymentGroupsError::ApplicationDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentGroupsError::ApplicationNameRequired(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentGroupsError::BatchLimitExceeded(ref cause) => write!(f, "{}", cause),
BatchGetDeploymentGroupsError::DeploymentConfigDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentGroupsError::DeploymentGroupNameRequired(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentGroupsError::InvalidApplicationName(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentGroupsError::InvalidDeploymentGroupName(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for BatchGetDeploymentGroupsError {}
#[derive(Debug, PartialEq)]
pub enum BatchGetDeploymentInstancesError {
BatchLimitExceeded(String),
DeploymentDoesNotExist(String),
DeploymentIdRequired(String),
InstanceIdRequired(String),
InvalidComputePlatform(String),
InvalidDeploymentId(String),
InvalidInstanceName(String),
}
impl BatchGetDeploymentInstancesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<BatchGetDeploymentInstancesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BatchLimitExceededException" => {
return RusotoError::Service(
BatchGetDeploymentInstancesError::BatchLimitExceeded(err.msg),
)
}
"DeploymentDoesNotExistException" => {
return RusotoError::Service(
BatchGetDeploymentInstancesError::DeploymentDoesNotExist(err.msg),
)
}
"DeploymentIdRequiredException" => {
return RusotoError::Service(
BatchGetDeploymentInstancesError::DeploymentIdRequired(err.msg),
)
}
"InstanceIdRequiredException" => {
return RusotoError::Service(
BatchGetDeploymentInstancesError::InstanceIdRequired(err.msg),
)
}
"InvalidComputePlatformException" => {
return RusotoError::Service(
BatchGetDeploymentInstancesError::InvalidComputePlatform(err.msg),
)
}
"InvalidDeploymentIdException" => {
return RusotoError::Service(
BatchGetDeploymentInstancesError::InvalidDeploymentId(err.msg),
)
}
"InvalidInstanceNameException" => {
return RusotoError::Service(
BatchGetDeploymentInstancesError::InvalidInstanceName(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGetDeploymentInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGetDeploymentInstancesError::BatchLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentInstancesError::DeploymentDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentInstancesError::DeploymentIdRequired(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentInstancesError::InstanceIdRequired(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentInstancesError::InvalidComputePlatform(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentInstancesError::InvalidDeploymentId(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentInstancesError::InvalidInstanceName(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for BatchGetDeploymentInstancesError {}
#[derive(Debug, PartialEq)]
pub enum BatchGetDeploymentTargetsError {
DeploymentDoesNotExist(String),
DeploymentIdRequired(String),
DeploymentNotStarted(String),
DeploymentTargetDoesNotExist(String),
DeploymentTargetIdRequired(String),
DeploymentTargetListSizeExceeded(String),
InstanceDoesNotExist(String),
InvalidDeploymentId(String),
InvalidDeploymentTargetId(String),
}
impl BatchGetDeploymentTargetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchGetDeploymentTargetsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DeploymentDoesNotExistException" => {
return RusotoError::Service(
BatchGetDeploymentTargetsError::DeploymentDoesNotExist(err.msg),
)
}
"DeploymentIdRequiredException" => {
return RusotoError::Service(
BatchGetDeploymentTargetsError::DeploymentIdRequired(err.msg),
)
}
"DeploymentNotStartedException" => {
return RusotoError::Service(
BatchGetDeploymentTargetsError::DeploymentNotStarted(err.msg),
)
}
"DeploymentTargetDoesNotExistException" => {
return RusotoError::Service(
BatchGetDeploymentTargetsError::DeploymentTargetDoesNotExist(err.msg),
)
}
"DeploymentTargetIdRequiredException" => {
return RusotoError::Service(
BatchGetDeploymentTargetsError::DeploymentTargetIdRequired(err.msg),
)
}
"DeploymentTargetListSizeExceededException" => {
return RusotoError::Service(
BatchGetDeploymentTargetsError::DeploymentTargetListSizeExceeded(err.msg),
)
}
"InstanceDoesNotExistException" => {
return RusotoError::Service(
BatchGetDeploymentTargetsError::InstanceDoesNotExist(err.msg),
)
}
"InvalidDeploymentIdException" => {
return RusotoError::Service(
BatchGetDeploymentTargetsError::InvalidDeploymentId(err.msg),
)
}
"InvalidDeploymentTargetIdException" => {
return RusotoError::Service(
BatchGetDeploymentTargetsError::InvalidDeploymentTargetId(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGetDeploymentTargetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGetDeploymentTargetsError::DeploymentDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentTargetsError::DeploymentIdRequired(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentTargetsError::DeploymentNotStarted(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentTargetsError::DeploymentTargetDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentTargetsError::DeploymentTargetIdRequired(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentTargetsError::DeploymentTargetListSizeExceeded(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentTargetsError::InstanceDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentTargetsError::InvalidDeploymentId(ref cause) => {
write!(f, "{}", cause)
}
BatchGetDeploymentTargetsError::InvalidDeploymentTargetId(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for BatchGetDeploymentTargetsError {}
#[derive(Debug, PartialEq)]
pub enum BatchGetDeploymentsError {
BatchLimitExceeded(String),
DeploymentIdRequired(String),
InvalidDeploymentId(String),
}
impl BatchGetDeploymentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchGetDeploymentsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BatchLimitExceededException" => {
return RusotoError::Service(BatchGetDeploymentsError::BatchLimitExceeded(
err.msg,
))
}
"DeploymentIdRequiredException" => {
return RusotoError::Service(BatchGetDeploymentsError::DeploymentIdRequired(
err.msg,
))
}
"InvalidDeploymentIdException" => {
return RusotoError::Service(BatchGetDeploymentsError::InvalidDeploymentId(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGetDeploymentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGetDeploymentsError::BatchLimitExceeded(ref cause) => write!(f, "{}", cause),
BatchGetDeploymentsError::DeploymentIdRequired(ref cause) => write!(f, "{}", cause),
BatchGetDeploymentsError::InvalidDeploymentId(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchGetDeploymentsError {}
#[derive(Debug, PartialEq)]
pub enum BatchGetOnPremisesInstancesError {
BatchLimitExceeded(String),
InstanceNameRequired(String),
InvalidInstanceName(String),
}
impl BatchGetOnPremisesInstancesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<BatchGetOnPremisesInstancesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BatchLimitExceededException" => {
return RusotoError::Service(
BatchGetOnPremisesInstancesError::BatchLimitExceeded(err.msg),
)
}
"InstanceNameRequiredException" => {
return RusotoError::Service(
BatchGetOnPremisesInstancesError::InstanceNameRequired(err.msg),
)
}
"InvalidInstanceNameException" => {
return RusotoError::Service(
BatchGetOnPremisesInstancesError::InvalidInstanceName(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGetOnPremisesInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGetOnPremisesInstancesError::BatchLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
BatchGetOnPremisesInstancesError::InstanceNameRequired(ref cause) => {
write!(f, "{}", cause)
}
BatchGetOnPremisesInstancesError::InvalidInstanceName(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for BatchGetOnPremisesInstancesError {}
#[derive(Debug, PartialEq)]
pub enum ContinueDeploymentError {
DeploymentAlreadyCompleted(String),
DeploymentDoesNotExist(String),
DeploymentIdRequired(String),
DeploymentIsNotInReadyState(String),
InvalidDeploymentId(String),
InvalidDeploymentStatus(String),
InvalidDeploymentWaitType(String),
UnsupportedActionForDeploymentType(String),
}
impl ContinueDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ContinueDeploymentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DeploymentAlreadyCompletedException" => {
return RusotoError::Service(
ContinueDeploymentError::DeploymentAlreadyCompleted(err.msg),
)
}
"DeploymentDoesNotExistException" => {
return RusotoError::Service(ContinueDeploymentError::DeploymentDoesNotExist(
err.msg,
))
}
"DeploymentIdRequiredException" => {
return RusotoError::Service(ContinueDeploymentError::DeploymentIdRequired(
err.msg,
))
}
"DeploymentIsNotInReadyStateException" => {
return RusotoError::Service(
ContinueDeploymentError::DeploymentIsNotInReadyState(err.msg),
)
}
"InvalidDeploymentIdException" => {
return RusotoError::Service(ContinueDeploymentError::InvalidDeploymentId(
err.msg,
))
}
"InvalidDeploymentStatusException" => {
return RusotoError::Service(ContinueDeploymentError::InvalidDeploymentStatus(
err.msg,
))
}
"InvalidDeploymentWaitTypeException" => {
return RusotoError::Service(
ContinueDeploymentError::InvalidDeploymentWaitType(err.msg),
)
}
"UnsupportedActionForDeploymentTypeException" => {
return RusotoError::Service(
ContinueDeploymentError::UnsupportedActionForDeploymentType(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ContinueDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ContinueDeploymentError::DeploymentAlreadyCompleted(ref cause) => {
write!(f, "{}", cause)
}
ContinueDeploymentError::DeploymentDoesNotExist(ref cause) => write!(f, "{}", cause),
ContinueDeploymentError::DeploymentIdRequired(ref cause) => write!(f, "{}", cause),
ContinueDeploymentError::DeploymentIsNotInReadyState(ref cause) => {
write!(f, "{}", cause)
}
ContinueDeploymentError::InvalidDeploymentId(ref cause) => write!(f, "{}", cause),
ContinueDeploymentError::InvalidDeploymentStatus(ref cause) => write!(f, "{}", cause),
ContinueDeploymentError::InvalidDeploymentWaitType(ref cause) => write!(f, "{}", cause),
ContinueDeploymentError::UnsupportedActionForDeploymentType(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ContinueDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum CreateApplicationError {
ApplicationAlreadyExists(String),
ApplicationLimitExceeded(String),
ApplicationNameRequired(String),
InvalidApplicationName(String),
InvalidComputePlatform(String),
InvalidTagsToAdd(String),
}
impl CreateApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationAlreadyExistsException" => {
return RusotoError::Service(CreateApplicationError::ApplicationAlreadyExists(
err.msg,
))
}
"ApplicationLimitExceededException" => {
return RusotoError::Service(CreateApplicationError::ApplicationLimitExceeded(
err.msg,
))
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(CreateApplicationError::ApplicationNameRequired(
err.msg,
))
}
"InvalidApplicationNameException" => {
return RusotoError::Service(CreateApplicationError::InvalidApplicationName(
err.msg,
))
}
"InvalidComputePlatformException" => {
return RusotoError::Service(CreateApplicationError::InvalidComputePlatform(
err.msg,
))
}
"InvalidTagsToAddException" => {
return RusotoError::Service(CreateApplicationError::InvalidTagsToAdd(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::ApplicationAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateApplicationError::ApplicationLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateApplicationError::ApplicationNameRequired(ref cause) => write!(f, "{}", cause),
CreateApplicationError::InvalidApplicationName(ref cause) => write!(f, "{}", cause),
CreateApplicationError::InvalidComputePlatform(ref cause) => write!(f, "{}", cause),
CreateApplicationError::InvalidTagsToAdd(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateApplicationError {}
#[derive(Debug, PartialEq)]
pub enum CreateDeploymentError {
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
DeploymentConfigDoesNotExist(String),
DeploymentGroupDoesNotExist(String),
DeploymentGroupNameRequired(String),
DeploymentLimitExceeded(String),
DescriptionTooLong(String),
InvalidApplicationName(String),
InvalidAutoRollbackConfig(String),
InvalidAutoScalingGroup(String),
InvalidDeploymentConfigName(String),
InvalidDeploymentGroupName(String),
InvalidFileExistsBehavior(String),
InvalidGitHubAccountToken(String),
InvalidIgnoreApplicationStopFailuresValue(String),
InvalidLoadBalancerInfo(String),
InvalidRevision(String),
InvalidRole(String),
InvalidTargetInstances(String),
InvalidTrafficRoutingConfiguration(String),
InvalidUpdateOutdatedInstancesOnlyValue(String),
RevisionDoesNotExist(String),
RevisionRequired(String),
Throttling(String),
}
impl CreateDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDeploymentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationDoesNotExistException" => {
return RusotoError::Service(CreateDeploymentError::ApplicationDoesNotExist(
err.msg,
))
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(CreateDeploymentError::ApplicationNameRequired(
err.msg,
))
}
"DeploymentConfigDoesNotExistException" => {
return RusotoError::Service(
CreateDeploymentError::DeploymentConfigDoesNotExist(err.msg),
)
}
"DeploymentGroupDoesNotExistException" => {
return RusotoError::Service(
CreateDeploymentError::DeploymentGroupDoesNotExist(err.msg),
)
}
"DeploymentGroupNameRequiredException" => {
return RusotoError::Service(
CreateDeploymentError::DeploymentGroupNameRequired(err.msg),
)
}
"DeploymentLimitExceededException" => {
return RusotoError::Service(CreateDeploymentError::DeploymentLimitExceeded(
err.msg,
))
}
"DescriptionTooLongException" => {
return RusotoError::Service(CreateDeploymentError::DescriptionTooLong(err.msg))
}
"InvalidApplicationNameException" => {
return RusotoError::Service(CreateDeploymentError::InvalidApplicationName(
err.msg,
))
}
"InvalidAutoRollbackConfigException" => {
return RusotoError::Service(CreateDeploymentError::InvalidAutoRollbackConfig(
err.msg,
))
}
"InvalidAutoScalingGroupException" => {
return RusotoError::Service(CreateDeploymentError::InvalidAutoScalingGroup(
err.msg,
))
}
"InvalidDeploymentConfigNameException" => {
return RusotoError::Service(
CreateDeploymentError::InvalidDeploymentConfigName(err.msg),
)
}
"InvalidDeploymentGroupNameException" => {
return RusotoError::Service(CreateDeploymentError::InvalidDeploymentGroupName(
err.msg,
))
}
"InvalidFileExistsBehaviorException" => {
return RusotoError::Service(CreateDeploymentError::InvalidFileExistsBehavior(
err.msg,
))
}
"InvalidGitHubAccountTokenException" => {
return RusotoError::Service(CreateDeploymentError::InvalidGitHubAccountToken(
err.msg,
))
}
"InvalidIgnoreApplicationStopFailuresValueException" => {
return RusotoError::Service(
CreateDeploymentError::InvalidIgnoreApplicationStopFailuresValue(err.msg),
)
}
"InvalidLoadBalancerInfoException" => {
return RusotoError::Service(CreateDeploymentError::InvalidLoadBalancerInfo(
err.msg,
))
}
"InvalidRevisionException" => {
return RusotoError::Service(CreateDeploymentError::InvalidRevision(err.msg))
}
"InvalidRoleException" => {
return RusotoError::Service(CreateDeploymentError::InvalidRole(err.msg))
}
"InvalidTargetInstancesException" => {
return RusotoError::Service(CreateDeploymentError::InvalidTargetInstances(
err.msg,
))
}
"InvalidTrafficRoutingConfigurationException" => {
return RusotoError::Service(
CreateDeploymentError::InvalidTrafficRoutingConfiguration(err.msg),
)
}
"InvalidUpdateOutdatedInstancesOnlyValueException" => {
return RusotoError::Service(
CreateDeploymentError::InvalidUpdateOutdatedInstancesOnlyValue(err.msg),
)
}
"RevisionDoesNotExistException" => {
return RusotoError::Service(CreateDeploymentError::RevisionDoesNotExist(
err.msg,
))
}
"RevisionRequiredException" => {
return RusotoError::Service(CreateDeploymentError::RevisionRequired(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreateDeploymentError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDeploymentError::ApplicationDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::ApplicationNameRequired(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::DeploymentConfigDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentError::DeploymentGroupDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::DeploymentGroupNameRequired(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::DeploymentLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::DescriptionTooLong(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::InvalidApplicationName(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::InvalidAutoRollbackConfig(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::InvalidAutoScalingGroup(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::InvalidDeploymentConfigName(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::InvalidDeploymentGroupName(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::InvalidFileExistsBehavior(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::InvalidGitHubAccountToken(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::InvalidIgnoreApplicationStopFailuresValue(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentError::InvalidLoadBalancerInfo(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::InvalidRevision(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::InvalidRole(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::InvalidTargetInstances(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::InvalidTrafficRoutingConfiguration(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentError::InvalidUpdateOutdatedInstancesOnlyValue(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentError::RevisionDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::RevisionRequired(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum CreateDeploymentConfigError {
DeploymentConfigAlreadyExists(String),
DeploymentConfigLimitExceeded(String),
DeploymentConfigNameRequired(String),
InvalidComputePlatform(String),
InvalidDeploymentConfigName(String),
InvalidMinimumHealthyHostValue(String),
InvalidTrafficRoutingConfiguration(String),
}
impl CreateDeploymentConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDeploymentConfigError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DeploymentConfigAlreadyExistsException" => {
return RusotoError::Service(
CreateDeploymentConfigError::DeploymentConfigAlreadyExists(err.msg),
)
}
"DeploymentConfigLimitExceededException" => {
return RusotoError::Service(
CreateDeploymentConfigError::DeploymentConfigLimitExceeded(err.msg),
)
}
"DeploymentConfigNameRequiredException" => {
return RusotoError::Service(
CreateDeploymentConfigError::DeploymentConfigNameRequired(err.msg),
)
}
"InvalidComputePlatformException" => {
return RusotoError::Service(
CreateDeploymentConfigError::InvalidComputePlatform(err.msg),
)
}
"InvalidDeploymentConfigNameException" => {
return RusotoError::Service(
CreateDeploymentConfigError::InvalidDeploymentConfigName(err.msg),
)
}
"InvalidMinimumHealthyHostValueException" => {
return RusotoError::Service(
CreateDeploymentConfigError::InvalidMinimumHealthyHostValue(err.msg),
)
}
"InvalidTrafficRoutingConfigurationException" => {
return RusotoError::Service(
CreateDeploymentConfigError::InvalidTrafficRoutingConfiguration(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDeploymentConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDeploymentConfigError::DeploymentConfigAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentConfigError::DeploymentConfigLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentConfigError::DeploymentConfigNameRequired(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentConfigError::InvalidComputePlatform(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentConfigError::InvalidDeploymentConfigName(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentConfigError::InvalidMinimumHealthyHostValue(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentConfigError::InvalidTrafficRoutingConfiguration(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateDeploymentConfigError {}
#[derive(Debug, PartialEq)]
pub enum CreateDeploymentGroupError {
AlarmsLimitExceeded(String),
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
DeploymentConfigDoesNotExist(String),
DeploymentGroupAlreadyExists(String),
DeploymentGroupLimitExceeded(String),
DeploymentGroupNameRequired(String),
ECSServiceMappingLimitExceeded(String),
InvalidAlarmConfig(String),
InvalidApplicationName(String),
InvalidAutoRollbackConfig(String),
InvalidAutoScalingGroup(String),
InvalidBlueGreenDeploymentConfiguration(String),
InvalidDeploymentConfigName(String),
InvalidDeploymentGroupName(String),
InvalidDeploymentStyle(String),
InvalidEC2TagCombination(String),
InvalidEC2Tag(String),
InvalidECSService(String),
InvalidInput(String),
InvalidLoadBalancerInfo(String),
InvalidOnPremisesTagCombination(String),
InvalidRole(String),
InvalidTag(String),
InvalidTagsToAdd(String),
InvalidTargetGroupPair(String),
InvalidTrafficRoutingConfiguration(String),
InvalidTriggerConfig(String),
LifecycleHookLimitExceeded(String),
RoleRequired(String),
TagSetListLimitExceeded(String),
Throttling(String),
TriggerTargetsLimitExceeded(String),
}
impl CreateDeploymentGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDeploymentGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AlarmsLimitExceededException" => {
return RusotoError::Service(CreateDeploymentGroupError::AlarmsLimitExceeded(
err.msg,
))
}
"ApplicationDoesNotExistException" => {
return RusotoError::Service(
CreateDeploymentGroupError::ApplicationDoesNotExist(err.msg),
)
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(
CreateDeploymentGroupError::ApplicationNameRequired(err.msg),
)
}
"DeploymentConfigDoesNotExistException" => {
return RusotoError::Service(
CreateDeploymentGroupError::DeploymentConfigDoesNotExist(err.msg),
)
}
"DeploymentGroupAlreadyExistsException" => {
return RusotoError::Service(
CreateDeploymentGroupError::DeploymentGroupAlreadyExists(err.msg),
)
}
"DeploymentGroupLimitExceededException" => {
return RusotoError::Service(
CreateDeploymentGroupError::DeploymentGroupLimitExceeded(err.msg),
)
}
"DeploymentGroupNameRequiredException" => {
return RusotoError::Service(
CreateDeploymentGroupError::DeploymentGroupNameRequired(err.msg),
)
}
"ECSServiceMappingLimitExceededException" => {
return RusotoError::Service(
CreateDeploymentGroupError::ECSServiceMappingLimitExceeded(err.msg),
)
}
"InvalidAlarmConfigException" => {
return RusotoError::Service(CreateDeploymentGroupError::InvalidAlarmConfig(
err.msg,
))
}
"InvalidApplicationNameException" => {
return RusotoError::Service(
CreateDeploymentGroupError::InvalidApplicationName(err.msg),
)
}
"InvalidAutoRollbackConfigException" => {
return RusotoError::Service(
CreateDeploymentGroupError::InvalidAutoRollbackConfig(err.msg),
)
}
"InvalidAutoScalingGroupException" => {
return RusotoError::Service(
CreateDeploymentGroupError::InvalidAutoScalingGroup(err.msg),
)
}
"InvalidBlueGreenDeploymentConfigurationException" => {
return RusotoError::Service(
CreateDeploymentGroupError::InvalidBlueGreenDeploymentConfiguration(
err.msg,
),
)
}
"InvalidDeploymentConfigNameException" => {
return RusotoError::Service(
CreateDeploymentGroupError::InvalidDeploymentConfigName(err.msg),
)
}
"InvalidDeploymentGroupNameException" => {
return RusotoError::Service(
CreateDeploymentGroupError::InvalidDeploymentGroupName(err.msg),
)
}
"InvalidDeploymentStyleException" => {
return RusotoError::Service(
CreateDeploymentGroupError::InvalidDeploymentStyle(err.msg),
)
}
"InvalidEC2TagCombinationException" => {
return RusotoError::Service(
CreateDeploymentGroupError::InvalidEC2TagCombination(err.msg),
)
}
"InvalidEC2TagException" => {
return RusotoError::Service(CreateDeploymentGroupError::InvalidEC2Tag(err.msg))
}
"InvalidECSServiceException" => {
return RusotoError::Service(CreateDeploymentGroupError::InvalidECSService(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(CreateDeploymentGroupError::InvalidInput(err.msg))
}
"InvalidLoadBalancerInfoException" => {
return RusotoError::Service(
CreateDeploymentGroupError::InvalidLoadBalancerInfo(err.msg),
)
}
"InvalidOnPremisesTagCombinationException" => {
return RusotoError::Service(
CreateDeploymentGroupError::InvalidOnPremisesTagCombination(err.msg),
)
}
"InvalidRoleException" => {
return RusotoError::Service(CreateDeploymentGroupError::InvalidRole(err.msg))
}
"InvalidTagException" => {
return RusotoError::Service(CreateDeploymentGroupError::InvalidTag(err.msg))
}
"InvalidTagsToAddException" => {
return RusotoError::Service(CreateDeploymentGroupError::InvalidTagsToAdd(
err.msg,
))
}
"InvalidTargetGroupPairException" => {
return RusotoError::Service(
CreateDeploymentGroupError::InvalidTargetGroupPair(err.msg),
)
}
"InvalidTrafficRoutingConfigurationException" => {
return RusotoError::Service(
CreateDeploymentGroupError::InvalidTrafficRoutingConfiguration(err.msg),
)
}
"InvalidTriggerConfigException" => {
return RusotoError::Service(CreateDeploymentGroupError::InvalidTriggerConfig(
err.msg,
))
}
"LifecycleHookLimitExceededException" => {
return RusotoError::Service(
CreateDeploymentGroupError::LifecycleHookLimitExceeded(err.msg),
)
}
"RoleRequiredException" => {
return RusotoError::Service(CreateDeploymentGroupError::RoleRequired(err.msg))
}
"TagSetListLimitExceededException" => {
return RusotoError::Service(
CreateDeploymentGroupError::TagSetListLimitExceeded(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(CreateDeploymentGroupError::Throttling(err.msg))
}
"TriggerTargetsLimitExceededException" => {
return RusotoError::Service(
CreateDeploymentGroupError::TriggerTargetsLimitExceeded(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDeploymentGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDeploymentGroupError::AlarmsLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::ApplicationDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::ApplicationNameRequired(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::DeploymentConfigDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::DeploymentGroupAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::DeploymentGroupLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::DeploymentGroupNameRequired(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::ECSServiceMappingLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::InvalidAlarmConfig(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::InvalidApplicationName(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::InvalidAutoRollbackConfig(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::InvalidAutoScalingGroup(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::InvalidBlueGreenDeploymentConfiguration(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::InvalidDeploymentConfigName(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::InvalidDeploymentGroupName(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::InvalidDeploymentStyle(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::InvalidEC2TagCombination(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::InvalidEC2Tag(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::InvalidECSService(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::InvalidLoadBalancerInfo(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::InvalidOnPremisesTagCombination(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::InvalidRole(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::InvalidTag(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::InvalidTagsToAdd(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::InvalidTargetGroupPair(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::InvalidTrafficRoutingConfiguration(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::InvalidTriggerConfig(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::LifecycleHookLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::RoleRequired(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::TagSetListLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentGroupError::Throttling(ref cause) => write!(f, "{}", cause),
CreateDeploymentGroupError::TriggerTargetsLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateDeploymentGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationError {
ApplicationNameRequired(String),
InvalidApplicationName(String),
InvalidRole(String),
}
impl DeleteApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationNameRequiredException" => {
return RusotoError::Service(DeleteApplicationError::ApplicationNameRequired(
err.msg,
))
}
"InvalidApplicationNameException" => {
return RusotoError::Service(DeleteApplicationError::InvalidApplicationName(
err.msg,
))
}
"InvalidRoleException" => {
return RusotoError::Service(DeleteApplicationError::InvalidRole(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::ApplicationNameRequired(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::InvalidApplicationName(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::InvalidRole(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteApplicationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDeploymentConfigError {
DeploymentConfigInUse(String),
DeploymentConfigNameRequired(String),
InvalidDeploymentConfigName(String),
InvalidOperation(String),
}
impl DeleteDeploymentConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDeploymentConfigError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DeploymentConfigInUseException" => {
return RusotoError::Service(
DeleteDeploymentConfigError::DeploymentConfigInUse(err.msg),
)
}
"DeploymentConfigNameRequiredException" => {
return RusotoError::Service(
DeleteDeploymentConfigError::DeploymentConfigNameRequired(err.msg),
)
}
"InvalidDeploymentConfigNameException" => {
return RusotoError::Service(
DeleteDeploymentConfigError::InvalidDeploymentConfigName(err.msg),
)
}
"InvalidOperationException" => {
return RusotoError::Service(DeleteDeploymentConfigError::InvalidOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDeploymentConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDeploymentConfigError::DeploymentConfigInUse(ref cause) => write!(f, "{}", cause),
DeleteDeploymentConfigError::DeploymentConfigNameRequired(ref cause) => {
write!(f, "{}", cause)
}
DeleteDeploymentConfigError::InvalidDeploymentConfigName(ref cause) => {
write!(f, "{}", cause)
}
DeleteDeploymentConfigError::InvalidOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDeploymentConfigError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDeploymentGroupError {
ApplicationNameRequired(String),
DeploymentGroupNameRequired(String),
InvalidApplicationName(String),
InvalidDeploymentGroupName(String),
InvalidRole(String),
}
impl DeleteDeploymentGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDeploymentGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationNameRequiredException" => {
return RusotoError::Service(
DeleteDeploymentGroupError::ApplicationNameRequired(err.msg),
)
}
"DeploymentGroupNameRequiredException" => {
return RusotoError::Service(
DeleteDeploymentGroupError::DeploymentGroupNameRequired(err.msg),
)
}
"InvalidApplicationNameException" => {
return RusotoError::Service(
DeleteDeploymentGroupError::InvalidApplicationName(err.msg),
)
}
"InvalidDeploymentGroupNameException" => {
return RusotoError::Service(
DeleteDeploymentGroupError::InvalidDeploymentGroupName(err.msg),
)
}
"InvalidRoleException" => {
return RusotoError::Service(DeleteDeploymentGroupError::InvalidRole(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDeploymentGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDeploymentGroupError::ApplicationNameRequired(ref cause) => {
write!(f, "{}", cause)
}
DeleteDeploymentGroupError::DeploymentGroupNameRequired(ref cause) => {
write!(f, "{}", cause)
}
DeleteDeploymentGroupError::InvalidApplicationName(ref cause) => write!(f, "{}", cause),
DeleteDeploymentGroupError::InvalidDeploymentGroupName(ref cause) => {
write!(f, "{}", cause)
}
DeleteDeploymentGroupError::InvalidRole(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDeploymentGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteGitHubAccountTokenError {
GitHubAccountTokenDoesNotExist(String),
GitHubAccountTokenNameRequired(String),
InvalidGitHubAccountTokenName(String),
OperationNotSupported(String),
ResourceValidation(String),
}
impl DeleteGitHubAccountTokenError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteGitHubAccountTokenError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"GitHubAccountTokenDoesNotExistException" => {
return RusotoError::Service(
DeleteGitHubAccountTokenError::GitHubAccountTokenDoesNotExist(err.msg),
)
}
"GitHubAccountTokenNameRequiredException" => {
return RusotoError::Service(
DeleteGitHubAccountTokenError::GitHubAccountTokenNameRequired(err.msg),
)
}
"InvalidGitHubAccountTokenNameException" => {
return RusotoError::Service(
DeleteGitHubAccountTokenError::InvalidGitHubAccountTokenName(err.msg),
)
}
"OperationNotSupportedException" => {
return RusotoError::Service(
DeleteGitHubAccountTokenError::OperationNotSupported(err.msg),
)
}
"ResourceValidationException" => {
return RusotoError::Service(DeleteGitHubAccountTokenError::ResourceValidation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteGitHubAccountTokenError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteGitHubAccountTokenError::GitHubAccountTokenDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
DeleteGitHubAccountTokenError::GitHubAccountTokenNameRequired(ref cause) => {
write!(f, "{}", cause)
}
DeleteGitHubAccountTokenError::InvalidGitHubAccountTokenName(ref cause) => {
write!(f, "{}", cause)
}
DeleteGitHubAccountTokenError::OperationNotSupported(ref cause) => {
write!(f, "{}", cause)
}
DeleteGitHubAccountTokenError::ResourceValidation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteGitHubAccountTokenError {}
#[derive(Debug, PartialEq)]
pub enum DeleteResourcesByExternalIdError {}
impl DeleteResourcesByExternalIdError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteResourcesByExternalIdError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteResourcesByExternalIdError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DeleteResourcesByExternalIdError {}
#[derive(Debug, PartialEq)]
pub enum DeregisterOnPremisesInstanceError {
InstanceNameRequired(String),
InvalidInstanceName(String),
}
impl DeregisterOnPremisesInstanceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeregisterOnPremisesInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InstanceNameRequiredException" => {
return RusotoError::Service(
DeregisterOnPremisesInstanceError::InstanceNameRequired(err.msg),
)
}
"InvalidInstanceNameException" => {
return RusotoError::Service(
DeregisterOnPremisesInstanceError::InvalidInstanceName(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeregisterOnPremisesInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeregisterOnPremisesInstanceError::InstanceNameRequired(ref cause) => {
write!(f, "{}", cause)
}
DeregisterOnPremisesInstanceError::InvalidInstanceName(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeregisterOnPremisesInstanceError {}
#[derive(Debug, PartialEq)]
pub enum GetApplicationError {
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
InvalidApplicationName(String),
}
impl GetApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationDoesNotExistException" => {
return RusotoError::Service(GetApplicationError::ApplicationDoesNotExist(
err.msg,
))
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(GetApplicationError::ApplicationNameRequired(
err.msg,
))
}
"InvalidApplicationNameException" => {
return RusotoError::Service(GetApplicationError::InvalidApplicationName(
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::ApplicationDoesNotExist(ref cause) => write!(f, "{}", cause),
GetApplicationError::ApplicationNameRequired(ref cause) => write!(f, "{}", cause),
GetApplicationError::InvalidApplicationName(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetApplicationError {}
#[derive(Debug, PartialEq)]
pub enum GetApplicationRevisionError {
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
InvalidApplicationName(String),
InvalidRevision(String),
RevisionDoesNotExist(String),
RevisionRequired(String),
}
impl GetApplicationRevisionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetApplicationRevisionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationDoesNotExistException" => {
return RusotoError::Service(
GetApplicationRevisionError::ApplicationDoesNotExist(err.msg),
)
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(
GetApplicationRevisionError::ApplicationNameRequired(err.msg),
)
}
"InvalidApplicationNameException" => {
return RusotoError::Service(
GetApplicationRevisionError::InvalidApplicationName(err.msg),
)
}
"InvalidRevisionException" => {
return RusotoError::Service(GetApplicationRevisionError::InvalidRevision(
err.msg,
))
}
"RevisionDoesNotExistException" => {
return RusotoError::Service(GetApplicationRevisionError::RevisionDoesNotExist(
err.msg,
))
}
"RevisionRequiredException" => {
return RusotoError::Service(GetApplicationRevisionError::RevisionRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetApplicationRevisionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetApplicationRevisionError::ApplicationDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
GetApplicationRevisionError::ApplicationNameRequired(ref cause) => {
write!(f, "{}", cause)
}
GetApplicationRevisionError::InvalidApplicationName(ref cause) => {
write!(f, "{}", cause)
}
GetApplicationRevisionError::InvalidRevision(ref cause) => write!(f, "{}", cause),
GetApplicationRevisionError::RevisionDoesNotExist(ref cause) => write!(f, "{}", cause),
GetApplicationRevisionError::RevisionRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetApplicationRevisionError {}
#[derive(Debug, PartialEq)]
pub enum GetDeploymentError {
DeploymentDoesNotExist(String),
DeploymentIdRequired(String),
InvalidDeploymentId(String),
}
impl GetDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeploymentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DeploymentDoesNotExistException" => {
return RusotoError::Service(GetDeploymentError::DeploymentDoesNotExist(
err.msg,
))
}
"DeploymentIdRequiredException" => {
return RusotoError::Service(GetDeploymentError::DeploymentIdRequired(err.msg))
}
"InvalidDeploymentIdException" => {
return RusotoError::Service(GetDeploymentError::InvalidDeploymentId(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::DeploymentDoesNotExist(ref cause) => write!(f, "{}", cause),
GetDeploymentError::DeploymentIdRequired(ref cause) => write!(f, "{}", cause),
GetDeploymentError::InvalidDeploymentId(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum GetDeploymentConfigError {
DeploymentConfigDoesNotExist(String),
DeploymentConfigNameRequired(String),
InvalidComputePlatform(String),
InvalidDeploymentConfigName(String),
}
impl GetDeploymentConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeploymentConfigError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DeploymentConfigDoesNotExistException" => {
return RusotoError::Service(
GetDeploymentConfigError::DeploymentConfigDoesNotExist(err.msg),
)
}
"DeploymentConfigNameRequiredException" => {
return RusotoError::Service(
GetDeploymentConfigError::DeploymentConfigNameRequired(err.msg),
)
}
"InvalidComputePlatformException" => {
return RusotoError::Service(GetDeploymentConfigError::InvalidComputePlatform(
err.msg,
))
}
"InvalidDeploymentConfigNameException" => {
return RusotoError::Service(
GetDeploymentConfigError::InvalidDeploymentConfigName(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeploymentConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeploymentConfigError::DeploymentConfigDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
GetDeploymentConfigError::DeploymentConfigNameRequired(ref cause) => {
write!(f, "{}", cause)
}
GetDeploymentConfigError::InvalidComputePlatform(ref cause) => write!(f, "{}", cause),
GetDeploymentConfigError::InvalidDeploymentConfigName(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetDeploymentConfigError {}
#[derive(Debug, PartialEq)]
pub enum GetDeploymentGroupError {
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
DeploymentConfigDoesNotExist(String),
DeploymentGroupDoesNotExist(String),
DeploymentGroupNameRequired(String),
InvalidApplicationName(String),
InvalidDeploymentGroupName(String),
}
impl GetDeploymentGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeploymentGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationDoesNotExistException" => {
return RusotoError::Service(GetDeploymentGroupError::ApplicationDoesNotExist(
err.msg,
))
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(GetDeploymentGroupError::ApplicationNameRequired(
err.msg,
))
}
"DeploymentConfigDoesNotExistException" => {
return RusotoError::Service(
GetDeploymentGroupError::DeploymentConfigDoesNotExist(err.msg),
)
}
"DeploymentGroupDoesNotExistException" => {
return RusotoError::Service(
GetDeploymentGroupError::DeploymentGroupDoesNotExist(err.msg),
)
}
"DeploymentGroupNameRequiredException" => {
return RusotoError::Service(
GetDeploymentGroupError::DeploymentGroupNameRequired(err.msg),
)
}
"InvalidApplicationNameException" => {
return RusotoError::Service(GetDeploymentGroupError::InvalidApplicationName(
err.msg,
))
}
"InvalidDeploymentGroupNameException" => {
return RusotoError::Service(
GetDeploymentGroupError::InvalidDeploymentGroupName(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeploymentGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeploymentGroupError::ApplicationDoesNotExist(ref cause) => write!(f, "{}", cause),
GetDeploymentGroupError::ApplicationNameRequired(ref cause) => write!(f, "{}", cause),
GetDeploymentGroupError::DeploymentConfigDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
GetDeploymentGroupError::DeploymentGroupDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
GetDeploymentGroupError::DeploymentGroupNameRequired(ref cause) => {
write!(f, "{}", cause)
}
GetDeploymentGroupError::InvalidApplicationName(ref cause) => write!(f, "{}", cause),
GetDeploymentGroupError::InvalidDeploymentGroupName(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetDeploymentGroupError {}
#[derive(Debug, PartialEq)]
pub enum GetDeploymentInstanceError {
DeploymentDoesNotExist(String),
DeploymentIdRequired(String),
InstanceDoesNotExist(String),
InstanceIdRequired(String),
InvalidComputePlatform(String),
InvalidDeploymentId(String),
InvalidInstanceName(String),
}
impl GetDeploymentInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeploymentInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DeploymentDoesNotExistException" => {
return RusotoError::Service(
GetDeploymentInstanceError::DeploymentDoesNotExist(err.msg),
)
}
"DeploymentIdRequiredException" => {
return RusotoError::Service(GetDeploymentInstanceError::DeploymentIdRequired(
err.msg,
))
}
"InstanceDoesNotExistException" => {
return RusotoError::Service(GetDeploymentInstanceError::InstanceDoesNotExist(
err.msg,
))
}
"InstanceIdRequiredException" => {
return RusotoError::Service(GetDeploymentInstanceError::InstanceIdRequired(
err.msg,
))
}
"InvalidComputePlatformException" => {
return RusotoError::Service(
GetDeploymentInstanceError::InvalidComputePlatform(err.msg),
)
}
"InvalidDeploymentIdException" => {
return RusotoError::Service(GetDeploymentInstanceError::InvalidDeploymentId(
err.msg,
))
}
"InvalidInstanceNameException" => {
return RusotoError::Service(GetDeploymentInstanceError::InvalidInstanceName(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeploymentInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeploymentInstanceError::DeploymentDoesNotExist(ref cause) => write!(f, "{}", cause),
GetDeploymentInstanceError::DeploymentIdRequired(ref cause) => write!(f, "{}", cause),
GetDeploymentInstanceError::InstanceDoesNotExist(ref cause) => write!(f, "{}", cause),
GetDeploymentInstanceError::InstanceIdRequired(ref cause) => write!(f, "{}", cause),
GetDeploymentInstanceError::InvalidComputePlatform(ref cause) => write!(f, "{}", cause),
GetDeploymentInstanceError::InvalidDeploymentId(ref cause) => write!(f, "{}", cause),
GetDeploymentInstanceError::InvalidInstanceName(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeploymentInstanceError {}
#[derive(Debug, PartialEq)]
pub enum GetDeploymentTargetError {
DeploymentDoesNotExist(String),
DeploymentIdRequired(String),
DeploymentNotStarted(String),
DeploymentTargetDoesNotExist(String),
DeploymentTargetIdRequired(String),
InvalidDeploymentId(String),
InvalidDeploymentTargetId(String),
InvalidInstanceName(String),
}
impl GetDeploymentTargetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeploymentTargetError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DeploymentDoesNotExistException" => {
return RusotoError::Service(GetDeploymentTargetError::DeploymentDoesNotExist(
err.msg,
))
}
"DeploymentIdRequiredException" => {
return RusotoError::Service(GetDeploymentTargetError::DeploymentIdRequired(
err.msg,
))
}
"DeploymentNotStartedException" => {
return RusotoError::Service(GetDeploymentTargetError::DeploymentNotStarted(
err.msg,
))
}
"DeploymentTargetDoesNotExistException" => {
return RusotoError::Service(
GetDeploymentTargetError::DeploymentTargetDoesNotExist(err.msg),
)
}
"DeploymentTargetIdRequiredException" => {
return RusotoError::Service(
GetDeploymentTargetError::DeploymentTargetIdRequired(err.msg),
)
}
"InvalidDeploymentIdException" => {
return RusotoError::Service(GetDeploymentTargetError::InvalidDeploymentId(
err.msg,
))
}
"InvalidDeploymentTargetIdException" => {
return RusotoError::Service(
GetDeploymentTargetError::InvalidDeploymentTargetId(err.msg),
)
}
"InvalidInstanceNameException" => {
return RusotoError::Service(GetDeploymentTargetError::InvalidInstanceName(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeploymentTargetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeploymentTargetError::DeploymentDoesNotExist(ref cause) => write!(f, "{}", cause),
GetDeploymentTargetError::DeploymentIdRequired(ref cause) => write!(f, "{}", cause),
GetDeploymentTargetError::DeploymentNotStarted(ref cause) => write!(f, "{}", cause),
GetDeploymentTargetError::DeploymentTargetDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
GetDeploymentTargetError::DeploymentTargetIdRequired(ref cause) => {
write!(f, "{}", cause)
}
GetDeploymentTargetError::InvalidDeploymentId(ref cause) => write!(f, "{}", cause),
GetDeploymentTargetError::InvalidDeploymentTargetId(ref cause) => {
write!(f, "{}", cause)
}
GetDeploymentTargetError::InvalidInstanceName(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeploymentTargetError {}
#[derive(Debug, PartialEq)]
pub enum GetOnPremisesInstanceError {
InstanceNameRequired(String),
InstanceNotRegistered(String),
InvalidInstanceName(String),
}
impl GetOnPremisesInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetOnPremisesInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InstanceNameRequiredException" => {
return RusotoError::Service(GetOnPremisesInstanceError::InstanceNameRequired(
err.msg,
))
}
"InstanceNotRegisteredException" => {
return RusotoError::Service(GetOnPremisesInstanceError::InstanceNotRegistered(
err.msg,
))
}
"InvalidInstanceNameException" => {
return RusotoError::Service(GetOnPremisesInstanceError::InvalidInstanceName(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetOnPremisesInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetOnPremisesInstanceError::InstanceNameRequired(ref cause) => write!(f, "{}", cause),
GetOnPremisesInstanceError::InstanceNotRegistered(ref cause) => write!(f, "{}", cause),
GetOnPremisesInstanceError::InvalidInstanceName(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetOnPremisesInstanceError {}
#[derive(Debug, PartialEq)]
pub enum ListApplicationRevisionsError {
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
BucketNameFilterRequired(String),
InvalidApplicationName(String),
InvalidBucketNameFilter(String),
InvalidDeployedStateFilter(String),
InvalidKeyPrefixFilter(String),
InvalidNextToken(String),
InvalidSortBy(String),
InvalidSortOrder(String),
}
impl ListApplicationRevisionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListApplicationRevisionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationDoesNotExistException" => {
return RusotoError::Service(
ListApplicationRevisionsError::ApplicationDoesNotExist(err.msg),
)
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(
ListApplicationRevisionsError::ApplicationNameRequired(err.msg),
)
}
"BucketNameFilterRequiredException" => {
return RusotoError::Service(
ListApplicationRevisionsError::BucketNameFilterRequired(err.msg),
)
}
"InvalidApplicationNameException" => {
return RusotoError::Service(
ListApplicationRevisionsError::InvalidApplicationName(err.msg),
)
}
"InvalidBucketNameFilterException" => {
return RusotoError::Service(
ListApplicationRevisionsError::InvalidBucketNameFilter(err.msg),
)
}
"InvalidDeployedStateFilterException" => {
return RusotoError::Service(
ListApplicationRevisionsError::InvalidDeployedStateFilter(err.msg),
)
}
"InvalidKeyPrefixFilterException" => {
return RusotoError::Service(
ListApplicationRevisionsError::InvalidKeyPrefixFilter(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListApplicationRevisionsError::InvalidNextToken(
err.msg,
))
}
"InvalidSortByException" => {
return RusotoError::Service(ListApplicationRevisionsError::InvalidSortBy(
err.msg,
))
}
"InvalidSortOrderException" => {
return RusotoError::Service(ListApplicationRevisionsError::InvalidSortOrder(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListApplicationRevisionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListApplicationRevisionsError::ApplicationDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
ListApplicationRevisionsError::ApplicationNameRequired(ref cause) => {
write!(f, "{}", cause)
}
ListApplicationRevisionsError::BucketNameFilterRequired(ref cause) => {
write!(f, "{}", cause)
}
ListApplicationRevisionsError::InvalidApplicationName(ref cause) => {
write!(f, "{}", cause)
}
ListApplicationRevisionsError::InvalidBucketNameFilter(ref cause) => {
write!(f, "{}", cause)
}
ListApplicationRevisionsError::InvalidDeployedStateFilter(ref cause) => {
write!(f, "{}", cause)
}
ListApplicationRevisionsError::InvalidKeyPrefixFilter(ref cause) => {
write!(f, "{}", cause)
}
ListApplicationRevisionsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListApplicationRevisionsError::InvalidSortBy(ref cause) => write!(f, "{}", cause),
ListApplicationRevisionsError::InvalidSortOrder(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListApplicationRevisionsError {}
#[derive(Debug, PartialEq)]
pub enum ListApplicationsError {
InvalidNextToken(String),
}
impl ListApplicationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListApplicationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListApplicationsError::InvalidNextToken(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::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListApplicationsError {}
#[derive(Debug, PartialEq)]
pub enum ListDeploymentConfigsError {
InvalidNextToken(String),
}
impl ListDeploymentConfigsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDeploymentConfigsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListDeploymentConfigsError::InvalidNextToken(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDeploymentConfigsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDeploymentConfigsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDeploymentConfigsError {}
#[derive(Debug, PartialEq)]
pub enum ListDeploymentGroupsError {
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
InvalidApplicationName(String),
InvalidNextToken(String),
}
impl ListDeploymentGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDeploymentGroupsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationDoesNotExistException" => {
return RusotoError::Service(
ListDeploymentGroupsError::ApplicationDoesNotExist(err.msg),
)
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(
ListDeploymentGroupsError::ApplicationNameRequired(err.msg),
)
}
"InvalidApplicationNameException" => {
return RusotoError::Service(ListDeploymentGroupsError::InvalidApplicationName(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListDeploymentGroupsError::InvalidNextToken(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDeploymentGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDeploymentGroupsError::ApplicationDoesNotExist(ref cause) => write!(f, "{}", cause),
ListDeploymentGroupsError::ApplicationNameRequired(ref cause) => write!(f, "{}", cause),
ListDeploymentGroupsError::InvalidApplicationName(ref cause) => write!(f, "{}", cause),
ListDeploymentGroupsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDeploymentGroupsError {}
#[derive(Debug, PartialEq)]
pub enum ListDeploymentInstancesError {
DeploymentDoesNotExist(String),
DeploymentIdRequired(String),
DeploymentNotStarted(String),
InvalidComputePlatform(String),
InvalidDeploymentId(String),
InvalidDeploymentInstanceType(String),
InvalidInstanceStatus(String),
InvalidInstanceType(String),
InvalidNextToken(String),
InvalidTargetFilterName(String),
}
impl ListDeploymentInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDeploymentInstancesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DeploymentDoesNotExistException" => {
return RusotoError::Service(
ListDeploymentInstancesError::DeploymentDoesNotExist(err.msg),
)
}
"DeploymentIdRequiredException" => {
return RusotoError::Service(
ListDeploymentInstancesError::DeploymentIdRequired(err.msg),
)
}
"DeploymentNotStartedException" => {
return RusotoError::Service(
ListDeploymentInstancesError::DeploymentNotStarted(err.msg),
)
}
"InvalidComputePlatformException" => {
return RusotoError::Service(
ListDeploymentInstancesError::InvalidComputePlatform(err.msg),
)
}
"InvalidDeploymentIdException" => {
return RusotoError::Service(ListDeploymentInstancesError::InvalidDeploymentId(
err.msg,
))
}
"InvalidDeploymentInstanceTypeException" => {
return RusotoError::Service(
ListDeploymentInstancesError::InvalidDeploymentInstanceType(err.msg),
)
}
"InvalidInstanceStatusException" => {
return RusotoError::Service(
ListDeploymentInstancesError::InvalidInstanceStatus(err.msg),
)
}
"InvalidInstanceTypeException" => {
return RusotoError::Service(ListDeploymentInstancesError::InvalidInstanceType(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListDeploymentInstancesError::InvalidNextToken(
err.msg,
))
}
"InvalidTargetFilterNameException" => {
return RusotoError::Service(
ListDeploymentInstancesError::InvalidTargetFilterName(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDeploymentInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDeploymentInstancesError::DeploymentDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
ListDeploymentInstancesError::DeploymentIdRequired(ref cause) => write!(f, "{}", cause),
ListDeploymentInstancesError::DeploymentNotStarted(ref cause) => write!(f, "{}", cause),
ListDeploymentInstancesError::InvalidComputePlatform(ref cause) => {
write!(f, "{}", cause)
}
ListDeploymentInstancesError::InvalidDeploymentId(ref cause) => write!(f, "{}", cause),
ListDeploymentInstancesError::InvalidDeploymentInstanceType(ref cause) => {
write!(f, "{}", cause)
}
ListDeploymentInstancesError::InvalidInstanceStatus(ref cause) => {
write!(f, "{}", cause)
}
ListDeploymentInstancesError::InvalidInstanceType(ref cause) => write!(f, "{}", cause),
ListDeploymentInstancesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListDeploymentInstancesError::InvalidTargetFilterName(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListDeploymentInstancesError {}
#[derive(Debug, PartialEq)]
pub enum ListDeploymentTargetsError {
DeploymentDoesNotExist(String),
DeploymentIdRequired(String),
DeploymentNotStarted(String),
InvalidDeploymentId(String),
InvalidDeploymentInstanceType(String),
InvalidInstanceStatus(String),
InvalidInstanceType(String),
InvalidNextToken(String),
}
impl ListDeploymentTargetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDeploymentTargetsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DeploymentDoesNotExistException" => {
return RusotoError::Service(
ListDeploymentTargetsError::DeploymentDoesNotExist(err.msg),
)
}
"DeploymentIdRequiredException" => {
return RusotoError::Service(ListDeploymentTargetsError::DeploymentIdRequired(
err.msg,
))
}
"DeploymentNotStartedException" => {
return RusotoError::Service(ListDeploymentTargetsError::DeploymentNotStarted(
err.msg,
))
}
"InvalidDeploymentIdException" => {
return RusotoError::Service(ListDeploymentTargetsError::InvalidDeploymentId(
err.msg,
))
}
"InvalidDeploymentInstanceTypeException" => {
return RusotoError::Service(
ListDeploymentTargetsError::InvalidDeploymentInstanceType(err.msg),
)
}
"InvalidInstanceStatusException" => {
return RusotoError::Service(ListDeploymentTargetsError::InvalidInstanceStatus(
err.msg,
))
}
"InvalidInstanceTypeException" => {
return RusotoError::Service(ListDeploymentTargetsError::InvalidInstanceType(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListDeploymentTargetsError::InvalidNextToken(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDeploymentTargetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDeploymentTargetsError::DeploymentDoesNotExist(ref cause) => write!(f, "{}", cause),
ListDeploymentTargetsError::DeploymentIdRequired(ref cause) => write!(f, "{}", cause),
ListDeploymentTargetsError::DeploymentNotStarted(ref cause) => write!(f, "{}", cause),
ListDeploymentTargetsError::InvalidDeploymentId(ref cause) => write!(f, "{}", cause),
ListDeploymentTargetsError::InvalidDeploymentInstanceType(ref cause) => {
write!(f, "{}", cause)
}
ListDeploymentTargetsError::InvalidInstanceStatus(ref cause) => write!(f, "{}", cause),
ListDeploymentTargetsError::InvalidInstanceType(ref cause) => write!(f, "{}", cause),
ListDeploymentTargetsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDeploymentTargetsError {}
#[derive(Debug, PartialEq)]
pub enum ListDeploymentsError {
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
DeploymentGroupDoesNotExist(String),
DeploymentGroupNameRequired(String),
InvalidApplicationName(String),
InvalidDeploymentGroupName(String),
InvalidDeploymentStatus(String),
InvalidExternalId(String),
InvalidInput(String),
InvalidNextToken(String),
InvalidTimeRange(String),
}
impl ListDeploymentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDeploymentsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationDoesNotExistException" => {
return RusotoError::Service(ListDeploymentsError::ApplicationDoesNotExist(
err.msg,
))
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(ListDeploymentsError::ApplicationNameRequired(
err.msg,
))
}
"DeploymentGroupDoesNotExistException" => {
return RusotoError::Service(ListDeploymentsError::DeploymentGroupDoesNotExist(
err.msg,
))
}
"DeploymentGroupNameRequiredException" => {
return RusotoError::Service(ListDeploymentsError::DeploymentGroupNameRequired(
err.msg,
))
}
"InvalidApplicationNameException" => {
return RusotoError::Service(ListDeploymentsError::InvalidApplicationName(
err.msg,
))
}
"InvalidDeploymentGroupNameException" => {
return RusotoError::Service(ListDeploymentsError::InvalidDeploymentGroupName(
err.msg,
))
}
"InvalidDeploymentStatusException" => {
return RusotoError::Service(ListDeploymentsError::InvalidDeploymentStatus(
err.msg,
))
}
"InvalidExternalIdException" => {
return RusotoError::Service(ListDeploymentsError::InvalidExternalId(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(ListDeploymentsError::InvalidInput(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListDeploymentsError::InvalidNextToken(err.msg))
}
"InvalidTimeRangeException" => {
return RusotoError::Service(ListDeploymentsError::InvalidTimeRange(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::ApplicationDoesNotExist(ref cause) => write!(f, "{}", cause),
ListDeploymentsError::ApplicationNameRequired(ref cause) => write!(f, "{}", cause),
ListDeploymentsError::DeploymentGroupDoesNotExist(ref cause) => write!(f, "{}", cause),
ListDeploymentsError::DeploymentGroupNameRequired(ref cause) => write!(f, "{}", cause),
ListDeploymentsError::InvalidApplicationName(ref cause) => write!(f, "{}", cause),
ListDeploymentsError::InvalidDeploymentGroupName(ref cause) => write!(f, "{}", cause),
ListDeploymentsError::InvalidDeploymentStatus(ref cause) => write!(f, "{}", cause),
ListDeploymentsError::InvalidExternalId(ref cause) => write!(f, "{}", cause),
ListDeploymentsError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListDeploymentsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListDeploymentsError::InvalidTimeRange(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDeploymentsError {}
#[derive(Debug, PartialEq)]
pub enum ListGitHubAccountTokenNamesError {
InvalidNextToken(String),
OperationNotSupported(String),
ResourceValidation(String),
}
impl ListGitHubAccountTokenNamesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListGitHubAccountTokenNamesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(
ListGitHubAccountTokenNamesError::InvalidNextToken(err.msg),
)
}
"OperationNotSupportedException" => {
return RusotoError::Service(
ListGitHubAccountTokenNamesError::OperationNotSupported(err.msg),
)
}
"ResourceValidationException" => {
return RusotoError::Service(
ListGitHubAccountTokenNamesError::ResourceValidation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListGitHubAccountTokenNamesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListGitHubAccountTokenNamesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListGitHubAccountTokenNamesError::OperationNotSupported(ref cause) => {
write!(f, "{}", cause)
}
ListGitHubAccountTokenNamesError::ResourceValidation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListGitHubAccountTokenNamesError {}
#[derive(Debug, PartialEq)]
pub enum ListOnPremisesInstancesError {
InvalidNextToken(String),
InvalidRegistrationStatus(String),
InvalidTagFilter(String),
}
impl ListOnPremisesInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListOnPremisesInstancesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListOnPremisesInstancesError::InvalidNextToken(
err.msg,
))
}
"InvalidRegistrationStatusException" => {
return RusotoError::Service(
ListOnPremisesInstancesError::InvalidRegistrationStatus(err.msg),
)
}
"InvalidTagFilterException" => {
return RusotoError::Service(ListOnPremisesInstancesError::InvalidTagFilter(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListOnPremisesInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListOnPremisesInstancesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListOnPremisesInstancesError::InvalidRegistrationStatus(ref cause) => {
write!(f, "{}", cause)
}
ListOnPremisesInstancesError::InvalidTagFilter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListOnPremisesInstancesError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
ArnNotSupported(String),
InvalidArn(String),
ResourceArnRequired(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ArnNotSupportedException" => {
return RusotoError::Service(ListTagsForResourceError::ArnNotSupported(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidArn(err.msg))
}
"ResourceArnRequiredException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceArnRequired(
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::ArnNotSupported(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceArnRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum PutLifecycleEventHookExecutionStatusError {
DeploymentDoesNotExist(String),
DeploymentIdRequired(String),
InvalidDeploymentId(String),
InvalidLifecycleEventHookExecutionId(String),
InvalidLifecycleEventHookExecutionStatus(String),
LifecycleEventAlreadyCompleted(String),
UnsupportedActionForDeploymentType(String),
}
impl PutLifecycleEventHookExecutionStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutLifecycleEventHookExecutionStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DeploymentDoesNotExistException" => return RusotoError::Service(PutLifecycleEventHookExecutionStatusError::DeploymentDoesNotExist(err.msg)),
"DeploymentIdRequiredException" => return RusotoError::Service(PutLifecycleEventHookExecutionStatusError::DeploymentIdRequired(err.msg)),
"InvalidDeploymentIdException" => return RusotoError::Service(PutLifecycleEventHookExecutionStatusError::InvalidDeploymentId(err.msg)),
"InvalidLifecycleEventHookExecutionIdException" => return RusotoError::Service(PutLifecycleEventHookExecutionStatusError::InvalidLifecycleEventHookExecutionId(err.msg)),
"InvalidLifecycleEventHookExecutionStatusException" => return RusotoError::Service(PutLifecycleEventHookExecutionStatusError::InvalidLifecycleEventHookExecutionStatus(err.msg)),
"LifecycleEventAlreadyCompletedException" => return RusotoError::Service(PutLifecycleEventHookExecutionStatusError::LifecycleEventAlreadyCompleted(err.msg)),
"UnsupportedActionForDeploymentTypeException" => return RusotoError::Service(PutLifecycleEventHookExecutionStatusError::UnsupportedActionForDeploymentType(err.msg)),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutLifecycleEventHookExecutionStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutLifecycleEventHookExecutionStatusError::DeploymentDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
PutLifecycleEventHookExecutionStatusError::DeploymentIdRequired(ref cause) => {
write!(f, "{}", cause)
}
PutLifecycleEventHookExecutionStatusError::InvalidDeploymentId(ref cause) => {
write!(f, "{}", cause)
}
PutLifecycleEventHookExecutionStatusError::InvalidLifecycleEventHookExecutionId(
ref cause,
) => write!(f, "{}", cause),
PutLifecycleEventHookExecutionStatusError::InvalidLifecycleEventHookExecutionStatus(
ref cause,
) => write!(f, "{}", cause),
PutLifecycleEventHookExecutionStatusError::LifecycleEventAlreadyCompleted(
ref cause,
) => write!(f, "{}", cause),
PutLifecycleEventHookExecutionStatusError::UnsupportedActionForDeploymentType(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for PutLifecycleEventHookExecutionStatusError {}
#[derive(Debug, PartialEq)]
pub enum RegisterApplicationRevisionError {
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
DescriptionTooLong(String),
InvalidApplicationName(String),
InvalidRevision(String),
RevisionRequired(String),
}
impl RegisterApplicationRevisionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RegisterApplicationRevisionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationDoesNotExistException" => {
return RusotoError::Service(
RegisterApplicationRevisionError::ApplicationDoesNotExist(err.msg),
)
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(
RegisterApplicationRevisionError::ApplicationNameRequired(err.msg),
)
}
"DescriptionTooLongException" => {
return RusotoError::Service(
RegisterApplicationRevisionError::DescriptionTooLong(err.msg),
)
}
"InvalidApplicationNameException" => {
return RusotoError::Service(
RegisterApplicationRevisionError::InvalidApplicationName(err.msg),
)
}
"InvalidRevisionException" => {
return RusotoError::Service(RegisterApplicationRevisionError::InvalidRevision(
err.msg,
))
}
"RevisionRequiredException" => {
return RusotoError::Service(
RegisterApplicationRevisionError::RevisionRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RegisterApplicationRevisionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RegisterApplicationRevisionError::ApplicationDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
RegisterApplicationRevisionError::ApplicationNameRequired(ref cause) => {
write!(f, "{}", cause)
}
RegisterApplicationRevisionError::DescriptionTooLong(ref cause) => {
write!(f, "{}", cause)
}
RegisterApplicationRevisionError::InvalidApplicationName(ref cause) => {
write!(f, "{}", cause)
}
RegisterApplicationRevisionError::InvalidRevision(ref cause) => write!(f, "{}", cause),
RegisterApplicationRevisionError::RevisionRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RegisterApplicationRevisionError {}
#[derive(Debug, PartialEq)]
pub enum RegisterOnPremisesInstanceError {
IamArnRequired(String),
IamSessionArnAlreadyRegistered(String),
IamUserArnAlreadyRegistered(String),
IamUserArnRequired(String),
InstanceNameAlreadyRegistered(String),
InstanceNameRequired(String),
InvalidIamSessionArn(String),
InvalidIamUserArn(String),
InvalidInstanceName(String),
MultipleIamArnsProvided(String),
}
impl RegisterOnPremisesInstanceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RegisterOnPremisesInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"IamArnRequiredException" => {
return RusotoError::Service(RegisterOnPremisesInstanceError::IamArnRequired(
err.msg,
))
}
"IamSessionArnAlreadyRegisteredException" => {
return RusotoError::Service(
RegisterOnPremisesInstanceError::IamSessionArnAlreadyRegistered(err.msg),
)
}
"IamUserArnAlreadyRegisteredException" => {
return RusotoError::Service(
RegisterOnPremisesInstanceError::IamUserArnAlreadyRegistered(err.msg),
)
}
"IamUserArnRequiredException" => {
return RusotoError::Service(
RegisterOnPremisesInstanceError::IamUserArnRequired(err.msg),
)
}
"InstanceNameAlreadyRegisteredException" => {
return RusotoError::Service(
RegisterOnPremisesInstanceError::InstanceNameAlreadyRegistered(err.msg),
)
}
"InstanceNameRequiredException" => {
return RusotoError::Service(
RegisterOnPremisesInstanceError::InstanceNameRequired(err.msg),
)
}
"InvalidIamSessionArnException" => {
return RusotoError::Service(
RegisterOnPremisesInstanceError::InvalidIamSessionArn(err.msg),
)
}
"InvalidIamUserArnException" => {
return RusotoError::Service(
RegisterOnPremisesInstanceError::InvalidIamUserArn(err.msg),
)
}
"InvalidInstanceNameException" => {
return RusotoError::Service(
RegisterOnPremisesInstanceError::InvalidInstanceName(err.msg),
)
}
"MultipleIamArnsProvidedException" => {
return RusotoError::Service(
RegisterOnPremisesInstanceError::MultipleIamArnsProvided(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RegisterOnPremisesInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RegisterOnPremisesInstanceError::IamArnRequired(ref cause) => write!(f, "{}", cause),
RegisterOnPremisesInstanceError::IamSessionArnAlreadyRegistered(ref cause) => {
write!(f, "{}", cause)
}
RegisterOnPremisesInstanceError::IamUserArnAlreadyRegistered(ref cause) => {
write!(f, "{}", cause)
}
RegisterOnPremisesInstanceError::IamUserArnRequired(ref cause) => {
write!(f, "{}", cause)
}
RegisterOnPremisesInstanceError::InstanceNameAlreadyRegistered(ref cause) => {
write!(f, "{}", cause)
}
RegisterOnPremisesInstanceError::InstanceNameRequired(ref cause) => {
write!(f, "{}", cause)
}
RegisterOnPremisesInstanceError::InvalidIamSessionArn(ref cause) => {
write!(f, "{}", cause)
}
RegisterOnPremisesInstanceError::InvalidIamUserArn(ref cause) => write!(f, "{}", cause),
RegisterOnPremisesInstanceError::InvalidInstanceName(ref cause) => {
write!(f, "{}", cause)
}
RegisterOnPremisesInstanceError::MultipleIamArnsProvided(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for RegisterOnPremisesInstanceError {}
#[derive(Debug, PartialEq)]
pub enum RemoveTagsFromOnPremisesInstancesError {
InstanceLimitExceeded(String),
InstanceNameRequired(String),
InstanceNotRegistered(String),
InvalidInstanceName(String),
InvalidTag(String),
TagLimitExceeded(String),
TagRequired(String),
}
impl RemoveTagsFromOnPremisesInstancesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RemoveTagsFromOnPremisesInstancesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InstanceLimitExceededException" => {
return RusotoError::Service(
RemoveTagsFromOnPremisesInstancesError::InstanceLimitExceeded(err.msg),
)
}
"InstanceNameRequiredException" => {
return RusotoError::Service(
RemoveTagsFromOnPremisesInstancesError::InstanceNameRequired(err.msg),
)
}
"InstanceNotRegisteredException" => {
return RusotoError::Service(
RemoveTagsFromOnPremisesInstancesError::InstanceNotRegistered(err.msg),
)
}
"InvalidInstanceNameException" => {
return RusotoError::Service(
RemoveTagsFromOnPremisesInstancesError::InvalidInstanceName(err.msg),
)
}
"InvalidTagException" => {
return RusotoError::Service(
RemoveTagsFromOnPremisesInstancesError::InvalidTag(err.msg),
)
}
"TagLimitExceededException" => {
return RusotoError::Service(
RemoveTagsFromOnPremisesInstancesError::TagLimitExceeded(err.msg),
)
}
"TagRequiredException" => {
return RusotoError::Service(
RemoveTagsFromOnPremisesInstancesError::TagRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RemoveTagsFromOnPremisesInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemoveTagsFromOnPremisesInstancesError::InstanceLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
RemoveTagsFromOnPremisesInstancesError::InstanceNameRequired(ref cause) => {
write!(f, "{}", cause)
}
RemoveTagsFromOnPremisesInstancesError::InstanceNotRegistered(ref cause) => {
write!(f, "{}", cause)
}
RemoveTagsFromOnPremisesInstancesError::InvalidInstanceName(ref cause) => {
write!(f, "{}", cause)
}
RemoveTagsFromOnPremisesInstancesError::InvalidTag(ref cause) => write!(f, "{}", cause),
RemoveTagsFromOnPremisesInstancesError::TagLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
RemoveTagsFromOnPremisesInstancesError::TagRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for RemoveTagsFromOnPremisesInstancesError {}
#[derive(Debug, PartialEq)]
pub enum SkipWaitTimeForInstanceTerminationError {
DeploymentAlreadyCompleted(String),
DeploymentDoesNotExist(String),
DeploymentIdRequired(String),
DeploymentNotStarted(String),
InvalidDeploymentId(String),
UnsupportedActionForDeploymentType(String),
}
impl SkipWaitTimeForInstanceTerminationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<SkipWaitTimeForInstanceTerminationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DeploymentAlreadyCompletedException" => {
return RusotoError::Service(
SkipWaitTimeForInstanceTerminationError::DeploymentAlreadyCompleted(
err.msg,
),
)
}
"DeploymentDoesNotExistException" => {
return RusotoError::Service(
SkipWaitTimeForInstanceTerminationError::DeploymentDoesNotExist(err.msg),
)
}
"DeploymentIdRequiredException" => {
return RusotoError::Service(
SkipWaitTimeForInstanceTerminationError::DeploymentIdRequired(err.msg),
)
}
"DeploymentNotStartedException" => {
return RusotoError::Service(
SkipWaitTimeForInstanceTerminationError::DeploymentNotStarted(err.msg),
)
}
"InvalidDeploymentIdException" => {
return RusotoError::Service(
SkipWaitTimeForInstanceTerminationError::InvalidDeploymentId(err.msg),
)
}
"UnsupportedActionForDeploymentTypeException" => {
return RusotoError::Service(
SkipWaitTimeForInstanceTerminationError::UnsupportedActionForDeploymentType(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SkipWaitTimeForInstanceTerminationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SkipWaitTimeForInstanceTerminationError::DeploymentAlreadyCompleted(ref cause) => {
write!(f, "{}", cause)
}
SkipWaitTimeForInstanceTerminationError::DeploymentDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
SkipWaitTimeForInstanceTerminationError::DeploymentIdRequired(ref cause) => {
write!(f, "{}", cause)
}
SkipWaitTimeForInstanceTerminationError::DeploymentNotStarted(ref cause) => {
write!(f, "{}", cause)
}
SkipWaitTimeForInstanceTerminationError::InvalidDeploymentId(ref cause) => {
write!(f, "{}", cause)
}
SkipWaitTimeForInstanceTerminationError::UnsupportedActionForDeploymentType(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for SkipWaitTimeForInstanceTerminationError {}
#[derive(Debug, PartialEq)]
pub enum StopDeploymentError {
DeploymentAlreadyCompleted(String),
DeploymentDoesNotExist(String),
DeploymentGroupDoesNotExist(String),
DeploymentIdRequired(String),
InvalidDeploymentId(String),
UnsupportedActionForDeploymentType(String),
}
impl StopDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopDeploymentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DeploymentAlreadyCompletedException" => {
return RusotoError::Service(StopDeploymentError::DeploymentAlreadyCompleted(
err.msg,
))
}
"DeploymentDoesNotExistException" => {
return RusotoError::Service(StopDeploymentError::DeploymentDoesNotExist(
err.msg,
))
}
"DeploymentGroupDoesNotExistException" => {
return RusotoError::Service(StopDeploymentError::DeploymentGroupDoesNotExist(
err.msg,
))
}
"DeploymentIdRequiredException" => {
return RusotoError::Service(StopDeploymentError::DeploymentIdRequired(err.msg))
}
"InvalidDeploymentIdException" => {
return RusotoError::Service(StopDeploymentError::InvalidDeploymentId(err.msg))
}
"UnsupportedActionForDeploymentTypeException" => {
return RusotoError::Service(
StopDeploymentError::UnsupportedActionForDeploymentType(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::DeploymentAlreadyCompleted(ref cause) => write!(f, "{}", cause),
StopDeploymentError::DeploymentDoesNotExist(ref cause) => write!(f, "{}", cause),
StopDeploymentError::DeploymentGroupDoesNotExist(ref cause) => write!(f, "{}", cause),
StopDeploymentError::DeploymentIdRequired(ref cause) => write!(f, "{}", cause),
StopDeploymentError::InvalidDeploymentId(ref cause) => write!(f, "{}", cause),
StopDeploymentError::UnsupportedActionForDeploymentType(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for StopDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
ApplicationDoesNotExist(String),
ArnNotSupported(String),
DeploymentConfigDoesNotExist(String),
DeploymentGroupDoesNotExist(String),
InvalidArn(String),
InvalidTagsToAdd(String),
ResourceArnRequired(String),
TagRequired(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationDoesNotExistException" => {
return RusotoError::Service(TagResourceError::ApplicationDoesNotExist(err.msg))
}
"ArnNotSupportedException" => {
return RusotoError::Service(TagResourceError::ArnNotSupported(err.msg))
}
"DeploymentConfigDoesNotExistException" => {
return RusotoError::Service(TagResourceError::DeploymentConfigDoesNotExist(
err.msg,
))
}
"DeploymentGroupDoesNotExistException" => {
return RusotoError::Service(TagResourceError::DeploymentGroupDoesNotExist(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(TagResourceError::InvalidArn(err.msg))
}
"InvalidTagsToAddException" => {
return RusotoError::Service(TagResourceError::InvalidTagsToAdd(err.msg))
}
"ResourceArnRequiredException" => {
return RusotoError::Service(TagResourceError::ResourceArnRequired(err.msg))
}
"TagRequiredException" => {
return RusotoError::Service(TagResourceError::TagRequired(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::ApplicationDoesNotExist(ref cause) => write!(f, "{}", cause),
TagResourceError::ArnNotSupported(ref cause) => write!(f, "{}", cause),
TagResourceError::DeploymentConfigDoesNotExist(ref cause) => write!(f, "{}", cause),
TagResourceError::DeploymentGroupDoesNotExist(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidArn(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidTagsToAdd(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceArnRequired(ref cause) => write!(f, "{}", cause),
TagResourceError::TagRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
ApplicationDoesNotExist(String),
ArnNotSupported(String),
DeploymentConfigDoesNotExist(String),
DeploymentGroupDoesNotExist(String),
InvalidArn(String),
InvalidTagsToAdd(String),
ResourceArnRequired(String),
TagRequired(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationDoesNotExistException" => {
return RusotoError::Service(UntagResourceError::ApplicationDoesNotExist(
err.msg,
))
}
"ArnNotSupportedException" => {
return RusotoError::Service(UntagResourceError::ArnNotSupported(err.msg))
}
"DeploymentConfigDoesNotExistException" => {
return RusotoError::Service(UntagResourceError::DeploymentConfigDoesNotExist(
err.msg,
))
}
"DeploymentGroupDoesNotExistException" => {
return RusotoError::Service(UntagResourceError::DeploymentGroupDoesNotExist(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(UntagResourceError::InvalidArn(err.msg))
}
"InvalidTagsToAddException" => {
return RusotoError::Service(UntagResourceError::InvalidTagsToAdd(err.msg))
}
"ResourceArnRequiredException" => {
return RusotoError::Service(UntagResourceError::ResourceArnRequired(err.msg))
}
"TagRequiredException" => {
return RusotoError::Service(UntagResourceError::TagRequired(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::ApplicationDoesNotExist(ref cause) => write!(f, "{}", cause),
UntagResourceError::ArnNotSupported(ref cause) => write!(f, "{}", cause),
UntagResourceError::DeploymentConfigDoesNotExist(ref cause) => write!(f, "{}", cause),
UntagResourceError::DeploymentGroupDoesNotExist(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidArn(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidTagsToAdd(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceArnRequired(ref cause) => write!(f, "{}", cause),
UntagResourceError::TagRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateApplicationError {
ApplicationAlreadyExists(String),
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
InvalidApplicationName(String),
}
impl UpdateApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApplicationAlreadyExistsException" => {
return RusotoError::Service(UpdateApplicationError::ApplicationAlreadyExists(
err.msg,
))
}
"ApplicationDoesNotExistException" => {
return RusotoError::Service(UpdateApplicationError::ApplicationDoesNotExist(
err.msg,
))
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(UpdateApplicationError::ApplicationNameRequired(
err.msg,
))
}
"InvalidApplicationNameException" => {
return RusotoError::Service(UpdateApplicationError::InvalidApplicationName(
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::ApplicationAlreadyExists(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::ApplicationDoesNotExist(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::ApplicationNameRequired(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::InvalidApplicationName(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateApplicationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDeploymentGroupError {
AlarmsLimitExceeded(String),
ApplicationDoesNotExist(String),
ApplicationNameRequired(String),
DeploymentConfigDoesNotExist(String),
DeploymentGroupAlreadyExists(String),
DeploymentGroupDoesNotExist(String),
DeploymentGroupNameRequired(String),
ECSServiceMappingLimitExceeded(String),
InvalidAlarmConfig(String),
InvalidApplicationName(String),
InvalidAutoRollbackConfig(String),
InvalidAutoScalingGroup(String),
InvalidBlueGreenDeploymentConfiguration(String),
InvalidDeploymentConfigName(String),
InvalidDeploymentGroupName(String),
InvalidDeploymentStyle(String),
InvalidEC2TagCombination(String),
InvalidEC2Tag(String),
InvalidECSService(String),
InvalidInput(String),
InvalidLoadBalancerInfo(String),
InvalidOnPremisesTagCombination(String),
InvalidRole(String),
InvalidTag(String),
InvalidTargetGroupPair(String),
InvalidTrafficRoutingConfiguration(String),
InvalidTriggerConfig(String),
LifecycleHookLimitExceeded(String),
TagSetListLimitExceeded(String),
Throttling(String),
TriggerTargetsLimitExceeded(String),
}
impl UpdateDeploymentGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDeploymentGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AlarmsLimitExceededException" => {
return RusotoError::Service(UpdateDeploymentGroupError::AlarmsLimitExceeded(
err.msg,
))
}
"ApplicationDoesNotExistException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::ApplicationDoesNotExist(err.msg),
)
}
"ApplicationNameRequiredException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::ApplicationNameRequired(err.msg),
)
}
"DeploymentConfigDoesNotExistException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::DeploymentConfigDoesNotExist(err.msg),
)
}
"DeploymentGroupAlreadyExistsException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::DeploymentGroupAlreadyExists(err.msg),
)
}
"DeploymentGroupDoesNotExistException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::DeploymentGroupDoesNotExist(err.msg),
)
}
"DeploymentGroupNameRequiredException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::DeploymentGroupNameRequired(err.msg),
)
}
"ECSServiceMappingLimitExceededException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::ECSServiceMappingLimitExceeded(err.msg),
)
}
"InvalidAlarmConfigException" => {
return RusotoError::Service(UpdateDeploymentGroupError::InvalidAlarmConfig(
err.msg,
))
}
"InvalidApplicationNameException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::InvalidApplicationName(err.msg),
)
}
"InvalidAutoRollbackConfigException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::InvalidAutoRollbackConfig(err.msg),
)
}
"InvalidAutoScalingGroupException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::InvalidAutoScalingGroup(err.msg),
)
}
"InvalidBlueGreenDeploymentConfigurationException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::InvalidBlueGreenDeploymentConfiguration(
err.msg,
),
)
}
"InvalidDeploymentConfigNameException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::InvalidDeploymentConfigName(err.msg),
)
}
"InvalidDeploymentGroupNameException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::InvalidDeploymentGroupName(err.msg),
)
}
"InvalidDeploymentStyleException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::InvalidDeploymentStyle(err.msg),
)
}
"InvalidEC2TagCombinationException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::InvalidEC2TagCombination(err.msg),
)
}
"InvalidEC2TagException" => {
return RusotoError::Service(UpdateDeploymentGroupError::InvalidEC2Tag(err.msg))
}
"InvalidECSServiceException" => {
return RusotoError::Service(UpdateDeploymentGroupError::InvalidECSService(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(UpdateDeploymentGroupError::InvalidInput(err.msg))
}
"InvalidLoadBalancerInfoException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::InvalidLoadBalancerInfo(err.msg),
)
}
"InvalidOnPremisesTagCombinationException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::InvalidOnPremisesTagCombination(err.msg),
)
}
"InvalidRoleException" => {
return RusotoError::Service(UpdateDeploymentGroupError::InvalidRole(err.msg))
}
"InvalidTagException" => {
return RusotoError::Service(UpdateDeploymentGroupError::InvalidTag(err.msg))
}
"InvalidTargetGroupPairException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::InvalidTargetGroupPair(err.msg),
)
}
"InvalidTrafficRoutingConfigurationException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::InvalidTrafficRoutingConfiguration(err.msg),
)
}
"InvalidTriggerConfigException" => {
return RusotoError::Service(UpdateDeploymentGroupError::InvalidTriggerConfig(
err.msg,
))
}
"LifecycleHookLimitExceededException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::LifecycleHookLimitExceeded(err.msg),
)
}
"TagSetListLimitExceededException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::TagSetListLimitExceeded(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(UpdateDeploymentGroupError::Throttling(err.msg))
}
"TriggerTargetsLimitExceededException" => {
return RusotoError::Service(
UpdateDeploymentGroupError::TriggerTargetsLimitExceeded(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDeploymentGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDeploymentGroupError::AlarmsLimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateDeploymentGroupError::ApplicationDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::ApplicationNameRequired(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::DeploymentConfigDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::DeploymentGroupAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::DeploymentGroupDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::DeploymentGroupNameRequired(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::ECSServiceMappingLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::InvalidAlarmConfig(ref cause) => write!(f, "{}", cause),
UpdateDeploymentGroupError::InvalidApplicationName(ref cause) => write!(f, "{}", cause),
UpdateDeploymentGroupError::InvalidAutoRollbackConfig(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::InvalidAutoScalingGroup(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::InvalidBlueGreenDeploymentConfiguration(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::InvalidDeploymentConfigName(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::InvalidDeploymentGroupName(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::InvalidDeploymentStyle(ref cause) => write!(f, "{}", cause),
UpdateDeploymentGroupError::InvalidEC2TagCombination(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::InvalidEC2Tag(ref cause) => write!(f, "{}", cause),
UpdateDeploymentGroupError::InvalidECSService(ref cause) => write!(f, "{}", cause),
UpdateDeploymentGroupError::InvalidInput(ref cause) => write!(f, "{}", cause),
UpdateDeploymentGroupError::InvalidLoadBalancerInfo(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::InvalidOnPremisesTagCombination(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::InvalidRole(ref cause) => write!(f, "{}", cause),
UpdateDeploymentGroupError::InvalidTag(ref cause) => write!(f, "{}", cause),
UpdateDeploymentGroupError::InvalidTargetGroupPair(ref cause) => write!(f, "{}", cause),
UpdateDeploymentGroupError::InvalidTrafficRoutingConfiguration(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::InvalidTriggerConfig(ref cause) => write!(f, "{}", cause),
UpdateDeploymentGroupError::LifecycleHookLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::TagSetListLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeploymentGroupError::Throttling(ref cause) => write!(f, "{}", cause),
UpdateDeploymentGroupError::TriggerTargetsLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateDeploymentGroupError {}
#[async_trait]
pub trait CodeDeploy {
async fn add_tags_to_on_premises_instances(
&self,
input: AddTagsToOnPremisesInstancesInput,
) -> Result<(), RusotoError<AddTagsToOnPremisesInstancesError>>;
async fn batch_get_application_revisions(
&self,
input: BatchGetApplicationRevisionsInput,
) -> Result<BatchGetApplicationRevisionsOutput, RusotoError<BatchGetApplicationRevisionsError>>;
async fn batch_get_applications(
&self,
input: BatchGetApplicationsInput,
) -> Result<BatchGetApplicationsOutput, RusotoError<BatchGetApplicationsError>>;
async fn batch_get_deployment_groups(
&self,
input: BatchGetDeploymentGroupsInput,
) -> Result<BatchGetDeploymentGroupsOutput, RusotoError<BatchGetDeploymentGroupsError>>;
async fn batch_get_deployment_instances(
&self,
input: BatchGetDeploymentInstancesInput,
) -> Result<BatchGetDeploymentInstancesOutput, RusotoError<BatchGetDeploymentInstancesError>>;
async fn batch_get_deployment_targets(
&self,
input: BatchGetDeploymentTargetsInput,
) -> Result<BatchGetDeploymentTargetsOutput, RusotoError<BatchGetDeploymentTargetsError>>;
async fn batch_get_deployments(
&self,
input: BatchGetDeploymentsInput,
) -> Result<BatchGetDeploymentsOutput, RusotoError<BatchGetDeploymentsError>>;
async fn batch_get_on_premises_instances(
&self,
input: BatchGetOnPremisesInstancesInput,
) -> Result<BatchGetOnPremisesInstancesOutput, RusotoError<BatchGetOnPremisesInstancesError>>;
async fn continue_deployment(
&self,
input: ContinueDeploymentInput,
) -> Result<(), RusotoError<ContinueDeploymentError>>;
async fn create_application(
&self,
input: CreateApplicationInput,
) -> Result<CreateApplicationOutput, RusotoError<CreateApplicationError>>;
async fn create_deployment(
&self,
input: CreateDeploymentInput,
) -> Result<CreateDeploymentOutput, RusotoError<CreateDeploymentError>>;
async fn create_deployment_config(
&self,
input: CreateDeploymentConfigInput,
) -> Result<CreateDeploymentConfigOutput, RusotoError<CreateDeploymentConfigError>>;
async fn create_deployment_group(
&self,
input: CreateDeploymentGroupInput,
) -> Result<CreateDeploymentGroupOutput, RusotoError<CreateDeploymentGroupError>>;
async fn delete_application(
&self,
input: DeleteApplicationInput,
) -> Result<(), RusotoError<DeleteApplicationError>>;
async fn delete_deployment_config(
&self,
input: DeleteDeploymentConfigInput,
) -> Result<(), RusotoError<DeleteDeploymentConfigError>>;
async fn delete_deployment_group(
&self,
input: DeleteDeploymentGroupInput,
) -> Result<DeleteDeploymentGroupOutput, RusotoError<DeleteDeploymentGroupError>>;
async fn delete_git_hub_account_token(
&self,
input: DeleteGitHubAccountTokenInput,
) -> Result<DeleteGitHubAccountTokenOutput, RusotoError<DeleteGitHubAccountTokenError>>;
async fn delete_resources_by_external_id(
&self,
input: DeleteResourcesByExternalIdInput,
) -> Result<DeleteResourcesByExternalIdOutput, RusotoError<DeleteResourcesByExternalIdError>>;
async fn deregister_on_premises_instance(
&self,
input: DeregisterOnPremisesInstanceInput,
) -> Result<(), RusotoError<DeregisterOnPremisesInstanceError>>;
async fn get_application(
&self,
input: GetApplicationInput,
) -> Result<GetApplicationOutput, RusotoError<GetApplicationError>>;
async fn get_application_revision(
&self,
input: GetApplicationRevisionInput,
) -> Result<GetApplicationRevisionOutput, RusotoError<GetApplicationRevisionError>>;
async fn get_deployment(
&self,
input: GetDeploymentInput,
) -> Result<GetDeploymentOutput, RusotoError<GetDeploymentError>>;
async fn get_deployment_config(
&self,
input: GetDeploymentConfigInput,
) -> Result<GetDeploymentConfigOutput, RusotoError<GetDeploymentConfigError>>;
async fn get_deployment_group(
&self,
input: GetDeploymentGroupInput,
) -> Result<GetDeploymentGroupOutput, RusotoError<GetDeploymentGroupError>>;
async fn get_deployment_instance(
&self,
input: GetDeploymentInstanceInput,
) -> Result<GetDeploymentInstanceOutput, RusotoError<GetDeploymentInstanceError>>;
async fn get_deployment_target(
&self,
input: GetDeploymentTargetInput,
) -> Result<GetDeploymentTargetOutput, RusotoError<GetDeploymentTargetError>>;
async fn get_on_premises_instance(
&self,
input: GetOnPremisesInstanceInput,
) -> Result<GetOnPremisesInstanceOutput, RusotoError<GetOnPremisesInstanceError>>;
async fn list_application_revisions(
&self,
input: ListApplicationRevisionsInput,
) -> Result<ListApplicationRevisionsOutput, RusotoError<ListApplicationRevisionsError>>;
async fn list_applications(
&self,
input: ListApplicationsInput,
) -> Result<ListApplicationsOutput, RusotoError<ListApplicationsError>>;
async fn list_deployment_configs(
&self,
input: ListDeploymentConfigsInput,
) -> Result<ListDeploymentConfigsOutput, RusotoError<ListDeploymentConfigsError>>;
async fn list_deployment_groups(
&self,
input: ListDeploymentGroupsInput,
) -> Result<ListDeploymentGroupsOutput, RusotoError<ListDeploymentGroupsError>>;
async fn list_deployment_instances(
&self,
input: ListDeploymentInstancesInput,
) -> Result<ListDeploymentInstancesOutput, RusotoError<ListDeploymentInstancesError>>;
async fn list_deployment_targets(
&self,
input: ListDeploymentTargetsInput,
) -> Result<ListDeploymentTargetsOutput, RusotoError<ListDeploymentTargetsError>>;
async fn list_deployments(
&self,
input: ListDeploymentsInput,
) -> Result<ListDeploymentsOutput, RusotoError<ListDeploymentsError>>;
async fn list_git_hub_account_token_names(
&self,
input: ListGitHubAccountTokenNamesInput,
) -> Result<ListGitHubAccountTokenNamesOutput, RusotoError<ListGitHubAccountTokenNamesError>>;
async fn list_on_premises_instances(
&self,
input: ListOnPremisesInstancesInput,
) -> Result<ListOnPremisesInstancesOutput, RusotoError<ListOnPremisesInstancesError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceInput,
) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>>;
async fn put_lifecycle_event_hook_execution_status(
&self,
input: PutLifecycleEventHookExecutionStatusInput,
) -> Result<
PutLifecycleEventHookExecutionStatusOutput,
RusotoError<PutLifecycleEventHookExecutionStatusError>,
>;
async fn register_application_revision(
&self,
input: RegisterApplicationRevisionInput,
) -> Result<(), RusotoError<RegisterApplicationRevisionError>>;
async fn register_on_premises_instance(
&self,
input: RegisterOnPremisesInstanceInput,
) -> Result<(), RusotoError<RegisterOnPremisesInstanceError>>;
async fn remove_tags_from_on_premises_instances(
&self,
input: RemoveTagsFromOnPremisesInstancesInput,
) -> Result<(), RusotoError<RemoveTagsFromOnPremisesInstancesError>>;
async fn skip_wait_time_for_instance_termination(
&self,
input: SkipWaitTimeForInstanceTerminationInput,
) -> Result<(), RusotoError<SkipWaitTimeForInstanceTerminationError>>;
async fn stop_deployment(
&self,
input: StopDeploymentInput,
) -> Result<StopDeploymentOutput, RusotoError<StopDeploymentError>>;
async fn tag_resource(
&self,
input: TagResourceInput,
) -> Result<TagResourceOutput, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceInput,
) -> Result<UntagResourceOutput, RusotoError<UntagResourceError>>;
async fn update_application(
&self,
input: UpdateApplicationInput,
) -> Result<(), RusotoError<UpdateApplicationError>>;
async fn update_deployment_group(
&self,
input: UpdateDeploymentGroupInput,
) -> Result<UpdateDeploymentGroupOutput, RusotoError<UpdateDeploymentGroupError>>;
}
#[derive(Clone)]
pub struct CodeDeployClient {
client: Client,
region: region::Region,
}
impl CodeDeployClient {
pub fn new(region: region::Region) -> CodeDeployClient {
CodeDeployClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CodeDeployClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
CodeDeployClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> CodeDeployClient {
CodeDeployClient { client, region }
}
}
#[async_trait]
impl CodeDeploy for CodeDeployClient {
async fn add_tags_to_on_premises_instances(
&self,
input: AddTagsToOnPremisesInstancesInput,
) -> Result<(), RusotoError<AddTagsToOnPremisesInstancesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.AddTagsToOnPremisesInstances",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AddTagsToOnPremisesInstancesError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn batch_get_application_revisions(
&self,
input: BatchGetApplicationRevisionsInput,
) -> Result<BatchGetApplicationRevisionsOutput, RusotoError<BatchGetApplicationRevisionsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.BatchGetApplicationRevisions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGetApplicationRevisionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchGetApplicationRevisionsOutput, _>()
}
async fn batch_get_applications(
&self,
input: BatchGetApplicationsInput,
) -> Result<BatchGetApplicationsOutput, RusotoError<BatchGetApplicationsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.BatchGetApplications");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGetApplicationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<BatchGetApplicationsOutput, _>()
}
async fn batch_get_deployment_groups(
&self,
input: BatchGetDeploymentGroupsInput,
) -> Result<BatchGetDeploymentGroupsOutput, RusotoError<BatchGetDeploymentGroupsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.BatchGetDeploymentGroups",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGetDeploymentGroupsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchGetDeploymentGroupsOutput, _>()
}
async fn batch_get_deployment_instances(
&self,
input: BatchGetDeploymentInstancesInput,
) -> Result<BatchGetDeploymentInstancesOutput, RusotoError<BatchGetDeploymentInstancesError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.BatchGetDeploymentInstances",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGetDeploymentInstancesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchGetDeploymentInstancesOutput, _>()
}
async fn batch_get_deployment_targets(
&self,
input: BatchGetDeploymentTargetsInput,
) -> Result<BatchGetDeploymentTargetsOutput, RusotoError<BatchGetDeploymentTargetsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.BatchGetDeploymentTargets",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGetDeploymentTargetsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchGetDeploymentTargetsOutput, _>()
}
async fn batch_get_deployments(
&self,
input: BatchGetDeploymentsInput,
) -> Result<BatchGetDeploymentsOutput, RusotoError<BatchGetDeploymentsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.BatchGetDeployments");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGetDeploymentsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<BatchGetDeploymentsOutput, _>()
}
async fn batch_get_on_premises_instances(
&self,
input: BatchGetOnPremisesInstancesInput,
) -> Result<BatchGetOnPremisesInstancesOutput, RusotoError<BatchGetOnPremisesInstancesError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.BatchGetOnPremisesInstances",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGetOnPremisesInstancesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchGetOnPremisesInstancesOutput, _>()
}
async fn continue_deployment(
&self,
input: ContinueDeploymentInput,
) -> Result<(), RusotoError<ContinueDeploymentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.ContinueDeployment");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ContinueDeploymentError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn create_application(
&self,
input: CreateApplicationInput,
) -> Result<CreateApplicationOutput, RusotoError<CreateApplicationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.CreateApplication");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateApplicationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateApplicationOutput, _>()
}
async fn create_deployment(
&self,
input: CreateDeploymentInput,
) -> Result<CreateDeploymentOutput, RusotoError<CreateDeploymentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.CreateDeployment");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDeploymentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateDeploymentOutput, _>()
}
async fn create_deployment_config(
&self,
input: CreateDeploymentConfigInput,
) -> Result<CreateDeploymentConfigOutput, RusotoError<CreateDeploymentConfigError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.CreateDeploymentConfig");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDeploymentConfigError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDeploymentConfigOutput, _>()
}
async fn create_deployment_group(
&self,
input: CreateDeploymentGroupInput,
) -> Result<CreateDeploymentGroupOutput, RusotoError<CreateDeploymentGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.CreateDeploymentGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDeploymentGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateDeploymentGroupOutput, _>()
}
async fn delete_application(
&self,
input: DeleteApplicationInput,
) -> Result<(), RusotoError<DeleteApplicationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.DeleteApplication");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteApplicationError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_deployment_config(
&self,
input: DeleteDeploymentConfigInput,
) -> Result<(), RusotoError<DeleteDeploymentConfigError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.DeleteDeploymentConfig");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDeploymentConfigError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_deployment_group(
&self,
input: DeleteDeploymentGroupInput,
) -> Result<DeleteDeploymentGroupOutput, RusotoError<DeleteDeploymentGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.DeleteDeploymentGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDeploymentGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteDeploymentGroupOutput, _>()
}
async fn delete_git_hub_account_token(
&self,
input: DeleteGitHubAccountTokenInput,
) -> Result<DeleteGitHubAccountTokenOutput, RusotoError<DeleteGitHubAccountTokenError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.DeleteGitHubAccountToken",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteGitHubAccountTokenError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteGitHubAccountTokenOutput, _>()
}
async fn delete_resources_by_external_id(
&self,
input: DeleteResourcesByExternalIdInput,
) -> Result<DeleteResourcesByExternalIdOutput, RusotoError<DeleteResourcesByExternalIdError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.DeleteResourcesByExternalId",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteResourcesByExternalIdError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteResourcesByExternalIdOutput, _>()
}
async fn deregister_on_premises_instance(
&self,
input: DeregisterOnPremisesInstanceInput,
) -> Result<(), RusotoError<DeregisterOnPremisesInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.DeregisterOnPremisesInstance",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeregisterOnPremisesInstanceError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn get_application(
&self,
input: GetApplicationInput,
) -> Result<GetApplicationOutput, RusotoError<GetApplicationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.GetApplication");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetApplicationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetApplicationOutput, _>()
}
async fn get_application_revision(
&self,
input: GetApplicationRevisionInput,
) -> Result<GetApplicationRevisionOutput, RusotoError<GetApplicationRevisionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.GetApplicationRevision");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetApplicationRevisionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetApplicationRevisionOutput, _>()
}
async fn get_deployment(
&self,
input: GetDeploymentInput,
) -> Result<GetDeploymentOutput, RusotoError<GetDeploymentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.GetDeployment");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDeploymentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDeploymentOutput, _>()
}
async fn get_deployment_config(
&self,
input: GetDeploymentConfigInput,
) -> Result<GetDeploymentConfigOutput, RusotoError<GetDeploymentConfigError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.GetDeploymentConfig");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDeploymentConfigError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDeploymentConfigOutput, _>()
}
async fn get_deployment_group(
&self,
input: GetDeploymentGroupInput,
) -> Result<GetDeploymentGroupOutput, RusotoError<GetDeploymentGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.GetDeploymentGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDeploymentGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDeploymentGroupOutput, _>()
}
async fn get_deployment_instance(
&self,
input: GetDeploymentInstanceInput,
) -> Result<GetDeploymentInstanceOutput, RusotoError<GetDeploymentInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.GetDeploymentInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDeploymentInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDeploymentInstanceOutput, _>()
}
async fn get_deployment_target(
&self,
input: GetDeploymentTargetInput,
) -> Result<GetDeploymentTargetOutput, RusotoError<GetDeploymentTargetError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.GetDeploymentTarget");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDeploymentTargetError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDeploymentTargetOutput, _>()
}
async fn get_on_premises_instance(
&self,
input: GetOnPremisesInstanceInput,
) -> Result<GetOnPremisesInstanceOutput, RusotoError<GetOnPremisesInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.GetOnPremisesInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetOnPremisesInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetOnPremisesInstanceOutput, _>()
}
async fn list_application_revisions(
&self,
input: ListApplicationRevisionsInput,
) -> Result<ListApplicationRevisionsOutput, RusotoError<ListApplicationRevisionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.ListApplicationRevisions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListApplicationRevisionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListApplicationRevisionsOutput, _>()
}
async fn list_applications(
&self,
input: ListApplicationsInput,
) -> Result<ListApplicationsOutput, RusotoError<ListApplicationsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.ListApplications");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListApplicationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListApplicationsOutput, _>()
}
async fn list_deployment_configs(
&self,
input: ListDeploymentConfigsInput,
) -> Result<ListDeploymentConfigsOutput, RusotoError<ListDeploymentConfigsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.ListDeploymentConfigs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDeploymentConfigsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListDeploymentConfigsOutput, _>()
}
async fn list_deployment_groups(
&self,
input: ListDeploymentGroupsInput,
) -> Result<ListDeploymentGroupsOutput, RusotoError<ListDeploymentGroupsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.ListDeploymentGroups");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDeploymentGroupsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListDeploymentGroupsOutput, _>()
}
async fn list_deployment_instances(
&self,
input: ListDeploymentInstancesInput,
) -> Result<ListDeploymentInstancesOutput, RusotoError<ListDeploymentInstancesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.ListDeploymentInstances",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDeploymentInstancesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListDeploymentInstancesOutput, _>()
}
async fn list_deployment_targets(
&self,
input: ListDeploymentTargetsInput,
) -> Result<ListDeploymentTargetsOutput, RusotoError<ListDeploymentTargetsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.ListDeploymentTargets");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDeploymentTargetsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListDeploymentTargetsOutput, _>()
}
async fn list_deployments(
&self,
input: ListDeploymentsInput,
) -> Result<ListDeploymentsOutput, RusotoError<ListDeploymentsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.ListDeployments");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDeploymentsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListDeploymentsOutput, _>()
}
async fn list_git_hub_account_token_names(
&self,
input: ListGitHubAccountTokenNamesInput,
) -> Result<ListGitHubAccountTokenNamesOutput, RusotoError<ListGitHubAccountTokenNamesError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.ListGitHubAccountTokenNames",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListGitHubAccountTokenNamesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListGitHubAccountTokenNamesOutput, _>()
}
async fn list_on_premises_instances(
&self,
input: ListOnPremisesInstancesInput,
) -> Result<ListOnPremisesInstancesOutput, RusotoError<ListOnPremisesInstancesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.ListOnPremisesInstances",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListOnPremisesInstancesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListOnPremisesInstancesOutput, _>()
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceInput,
) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.ListTagsForResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceOutput, _>()
}
async fn put_lifecycle_event_hook_execution_status(
&self,
input: PutLifecycleEventHookExecutionStatusInput,
) -> Result<
PutLifecycleEventHookExecutionStatusOutput,
RusotoError<PutLifecycleEventHookExecutionStatusError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.PutLifecycleEventHookExecutionStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
PutLifecycleEventHookExecutionStatusError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutLifecycleEventHookExecutionStatusOutput, _>()
}
async fn register_application_revision(
&self,
input: RegisterApplicationRevisionInput,
) -> Result<(), RusotoError<RegisterApplicationRevisionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.RegisterApplicationRevision",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RegisterApplicationRevisionError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn register_on_premises_instance(
&self,
input: RegisterOnPremisesInstanceInput,
) -> Result<(), RusotoError<RegisterOnPremisesInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.RegisterOnPremisesInstance",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RegisterOnPremisesInstanceError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn remove_tags_from_on_premises_instances(
&self,
input: RemoveTagsFromOnPremisesInstancesInput,
) -> Result<(), RusotoError<RemoveTagsFromOnPremisesInstancesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.RemoveTagsFromOnPremisesInstances",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
RemoveTagsFromOnPremisesInstancesError::from_response,
)
.await?;
std::mem::drop(response);
Ok(())
}
async fn skip_wait_time_for_instance_termination(
&self,
input: SkipWaitTimeForInstanceTerminationInput,
) -> Result<(), RusotoError<SkipWaitTimeForInstanceTerminationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeDeploy_20141006.SkipWaitTimeForInstanceTermination",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
SkipWaitTimeForInstanceTerminationError::from_response,
)
.await?;
std::mem::drop(response);
Ok(())
}
async fn stop_deployment(
&self,
input: StopDeploymentInput,
) -> Result<StopDeploymentOutput, RusotoError<StopDeploymentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.StopDeployment");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopDeploymentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StopDeploymentOutput, _>()
}
async fn tag_resource(
&self,
input: TagResourceInput,
) -> Result<TagResourceOutput, RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceOutput, _>()
}
async fn untag_resource(
&self,
input: UntagResourceInput,
) -> Result<UntagResourceOutput, RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceOutput, _>()
}
async fn update_application(
&self,
input: UpdateApplicationInput,
) -> Result<(), RusotoError<UpdateApplicationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.UpdateApplication");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateApplicationError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn update_deployment_group(
&self,
input: UpdateDeploymentGroupInput,
) -> Result<UpdateDeploymentGroupOutput, RusotoError<UpdateDeploymentGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeDeploy_20141006.UpdateDeploymentGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateDeploymentGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateDeploymentGroupOutput, _>()
}
}