use std::error::Error;
use std::fmt;
use std::io;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoFuture};
use rusoto_core::credential::{CredentialsError, ProvideAwsCredentials};
use rusoto_core::request::HttpDispatchError;
use rusoto_core::signature::SignedRequest;
use serde_json;
use serde_json::from_slice;
use serde_json::Value as SerdeJsonValue;
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AgentVersion {
#[serde(rename = "ConfigurationManager")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_manager: Option<StackConfigurationManager>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct App {
#[serde(rename = "AppId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
#[serde(rename = "AppSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_source: Option<Source>,
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "DataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<Vec<DataSource>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Domains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domains: Option<Vec<String>>,
#[serde(rename = "EnableSsl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_ssl: Option<bool>,
#[serde(rename = "Environment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<Vec<EnvironmentVariable>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Shortname")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shortname: Option<String>,
#[serde(rename = "SslConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_configuration: Option<SslConfiguration>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AssignInstanceRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "LayerIds")]
pub layer_ids: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AssignVolumeRequest {
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "VolumeId")]
pub volume_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AssociateElasticIpRequest {
#[serde(rename = "ElasticIp")]
pub elastic_ip: String,
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AttachElasticLoadBalancerRequest {
#[serde(rename = "ElasticLoadBalancerName")]
pub elastic_load_balancer_name: String,
#[serde(rename = "LayerId")]
pub layer_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AutoScalingThresholds {
#[serde(rename = "Alarms")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alarms: Option<Vec<String>>,
#[serde(rename = "CpuThreshold")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cpu_threshold: Option<f64>,
#[serde(rename = "IgnoreMetricsTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ignore_metrics_time: Option<i64>,
#[serde(rename = "InstanceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_count: Option<i64>,
#[serde(rename = "LoadThreshold")]
#[serde(skip_serializing_if = "Option::is_none")]
pub load_threshold: Option<f64>,
#[serde(rename = "MemoryThreshold")]
#[serde(skip_serializing_if = "Option::is_none")]
pub memory_threshold: Option<f64>,
#[serde(rename = "ThresholdsWaitTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub thresholds_wait_time: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BlockDeviceMapping {
#[serde(rename = "DeviceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_name: Option<String>,
#[serde(rename = "Ebs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ebs: Option<EbsBlockDevice>,
#[serde(rename = "NoDevice")]
#[serde(skip_serializing_if = "Option::is_none")]
pub no_device: Option<String>,
#[serde(rename = "VirtualName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ChefConfiguration {
#[serde(rename = "BerkshelfVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub berkshelf_version: Option<String>,
#[serde(rename = "ManageBerkshelf")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manage_berkshelf: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CloneStackRequest {
#[serde(rename = "AgentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_version: Option<String>,
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ChefConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub chef_configuration: Option<ChefConfiguration>,
#[serde(rename = "CloneAppIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub clone_app_ids: Option<Vec<String>>,
#[serde(rename = "ClonePermissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub clone_permissions: Option<bool>,
#[serde(rename = "ConfigurationManager")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_manager: Option<StackConfigurationManager>,
#[serde(rename = "CustomCookbooksSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_cookbooks_source: Option<Source>,
#[serde(rename = "CustomJson")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_json: Option<String>,
#[serde(rename = "DefaultAvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_availability_zone: Option<String>,
#[serde(rename = "DefaultInstanceProfileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_instance_profile_arn: Option<String>,
#[serde(rename = "DefaultOs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_os: Option<String>,
#[serde(rename = "DefaultRootDeviceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_root_device_type: Option<String>,
#[serde(rename = "DefaultSshKeyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_ssh_key_name: Option<String>,
#[serde(rename = "DefaultSubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_subnet_id: Option<String>,
#[serde(rename = "HostnameTheme")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hostname_theme: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "ServiceRoleArn")]
pub service_role_arn: String,
#[serde(rename = "SourceStackId")]
pub source_stack_id: String,
#[serde(rename = "UseCustomCookbooks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_custom_cookbooks: Option<bool>,
#[serde(rename = "UseOpsworksSecurityGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_opsworks_security_groups: Option<bool>,
#[serde(rename = "VpcId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CloneStackResult {
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CloudWatchLogsConfiguration {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "LogStreams")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_streams: Option<Vec<CloudWatchLogsLogStream>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CloudWatchLogsLogStream {
#[serde(rename = "BatchCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_count: Option<i64>,
#[serde(rename = "BatchSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_size: Option<i64>,
#[serde(rename = "BufferDuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub buffer_duration: Option<i64>,
#[serde(rename = "DatetimeFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datetime_format: Option<String>,
#[serde(rename = "Encoding")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encoding: Option<String>,
#[serde(rename = "File")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file: Option<String>,
#[serde(rename = "FileFingerprintLines")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_fingerprint_lines: Option<String>,
#[serde(rename = "InitialPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_position: Option<String>,
#[serde(rename = "LogGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_group_name: Option<String>,
#[serde(rename = "MultiLineStartPattern")]
#[serde(skip_serializing_if = "Option::is_none")]
pub multi_line_start_pattern: Option<String>,
#[serde(rename = "TimeZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub time_zone: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Command {
#[serde(rename = "AcknowledgedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub acknowledged_at: Option<String>,
#[serde(rename = "CommandId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub command_id: Option<String>,
#[serde(rename = "CompletedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completed_at: Option<String>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "ExitCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exit_code: Option<i64>,
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "LogUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_url: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateAppRequest {
#[serde(rename = "AppSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_source: Option<Source>,
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "DataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<Vec<DataSource>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Domains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domains: Option<Vec<String>>,
#[serde(rename = "EnableSsl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_ssl: Option<bool>,
#[serde(rename = "Environment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<Vec<EnvironmentVariable>>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Shortname")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shortname: Option<String>,
#[serde(rename = "SslConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_configuration: Option<SslConfiguration>,
#[serde(rename = "StackId")]
pub stack_id: String,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateAppResult {
#[serde(rename = "AppId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateDeploymentRequest {
#[serde(rename = "AppId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
#[serde(rename = "Command")]
pub command: DeploymentCommand,
#[serde(rename = "Comment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comment: Option<String>,
#[serde(rename = "CustomJson")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_json: Option<String>,
#[serde(rename = "InstanceIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_ids: Option<Vec<String>>,
#[serde(rename = "LayerIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_ids: Option<Vec<String>>,
#[serde(rename = "StackId")]
pub stack_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateDeploymentResult {
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateInstanceRequest {
#[serde(rename = "AgentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_version: Option<String>,
#[serde(rename = "AmiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ami_id: Option<String>,
#[serde(rename = "Architecture")]
#[serde(skip_serializing_if = "Option::is_none")]
pub architecture: Option<String>,
#[serde(rename = "AutoScalingType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_type: Option<String>,
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "BlockDeviceMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub block_device_mappings: Option<Vec<BlockDeviceMapping>>,
#[serde(rename = "EbsOptimized")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ebs_optimized: Option<bool>,
#[serde(rename = "Hostname")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hostname: Option<String>,
#[serde(rename = "InstallUpdatesOnBoot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub install_updates_on_boot: Option<bool>,
#[serde(rename = "InstanceType")]
pub instance_type: String,
#[serde(rename = "LayerIds")]
pub layer_ids: Vec<String>,
#[serde(rename = "Os")]
#[serde(skip_serializing_if = "Option::is_none")]
pub os: Option<String>,
#[serde(rename = "RootDeviceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub root_device_type: Option<String>,
#[serde(rename = "SshKeyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_key_name: Option<String>,
#[serde(rename = "StackId")]
pub stack_id: String,
#[serde(rename = "SubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
#[serde(rename = "Tenancy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tenancy: Option<String>,
#[serde(rename = "VirtualizationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtualization_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateInstanceResult {
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateLayerRequest {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "AutoAssignElasticIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_assign_elastic_ips: Option<bool>,
#[serde(rename = "AutoAssignPublicIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_assign_public_ips: Option<bool>,
#[serde(rename = "CloudWatchLogsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logs_configuration: Option<CloudWatchLogsConfiguration>,
#[serde(rename = "CustomInstanceProfileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_instance_profile_arn: Option<String>,
#[serde(rename = "CustomJson")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_json: Option<String>,
#[serde(rename = "CustomRecipes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_recipes: Option<Recipes>,
#[serde(rename = "CustomSecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_security_group_ids: Option<Vec<String>>,
#[serde(rename = "EnableAutoHealing")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_auto_healing: Option<bool>,
#[serde(rename = "InstallUpdatesOnBoot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub install_updates_on_boot: Option<bool>,
#[serde(rename = "LifecycleEventConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_event_configuration: Option<LifecycleEventConfiguration>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Packages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packages: Option<Vec<String>>,
#[serde(rename = "Shortname")]
pub shortname: String,
#[serde(rename = "StackId")]
pub stack_id: String,
#[serde(rename = "Type")]
pub type_: String,
#[serde(rename = "UseEbsOptimizedInstances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_ebs_optimized_instances: Option<bool>,
#[serde(rename = "VolumeConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_configurations: Option<Vec<VolumeConfiguration>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateLayerResult {
#[serde(rename = "LayerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateStackRequest {
#[serde(rename = "AgentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_version: Option<String>,
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ChefConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub chef_configuration: Option<ChefConfiguration>,
#[serde(rename = "ConfigurationManager")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_manager: Option<StackConfigurationManager>,
#[serde(rename = "CustomCookbooksSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_cookbooks_source: Option<Source>,
#[serde(rename = "CustomJson")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_json: Option<String>,
#[serde(rename = "DefaultAvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_availability_zone: Option<String>,
#[serde(rename = "DefaultInstanceProfileArn")]
pub default_instance_profile_arn: String,
#[serde(rename = "DefaultOs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_os: Option<String>,
#[serde(rename = "DefaultRootDeviceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_root_device_type: Option<String>,
#[serde(rename = "DefaultSshKeyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_ssh_key_name: Option<String>,
#[serde(rename = "DefaultSubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_subnet_id: Option<String>,
#[serde(rename = "HostnameTheme")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hostname_theme: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Region")]
pub region: String,
#[serde(rename = "ServiceRoleArn")]
pub service_role_arn: String,
#[serde(rename = "UseCustomCookbooks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_custom_cookbooks: Option<bool>,
#[serde(rename = "UseOpsworksSecurityGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_opsworks_security_groups: Option<bool>,
#[serde(rename = "VpcId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateStackResult {
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateUserProfileRequest {
#[serde(rename = "AllowSelfManagement")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_self_management: Option<bool>,
#[serde(rename = "IamUserArn")]
pub iam_user_arn: String,
#[serde(rename = "SshPublicKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_public_key: Option<String>,
#[serde(rename = "SshUsername")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_username: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateUserProfileResult {
#[serde(rename = "IamUserArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_user_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DataSource {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "DatabaseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database_name: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteAppRequest {
#[serde(rename = "AppId")]
pub app_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteInstanceRequest {
#[serde(rename = "DeleteElasticIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_elastic_ip: Option<bool>,
#[serde(rename = "DeleteVolumes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_volumes: Option<bool>,
#[serde(rename = "InstanceId")]
pub instance_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteLayerRequest {
#[serde(rename = "LayerId")]
pub layer_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteStackRequest {
#[serde(rename = "StackId")]
pub stack_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteUserProfileRequest {
#[serde(rename = "IamUserArn")]
pub iam_user_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Deployment {
#[serde(rename = "AppId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
#[serde(rename = "Command")]
#[serde(skip_serializing_if = "Option::is_none")]
pub command: Option<DeploymentCommand>,
#[serde(rename = "Comment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comment: Option<String>,
#[serde(rename = "CompletedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completed_at: Option<String>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "CustomJson")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_json: Option<String>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "Duration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub duration: Option<i64>,
#[serde(rename = "IamUserArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_user_arn: Option<String>,
#[serde(rename = "InstanceIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_ids: Option<Vec<String>>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DeploymentCommand {
#[serde(rename = "Args")]
#[serde(skip_serializing_if = "Option::is_none")]
pub args: Option<::std::collections::HashMap<String, Vec<String>>>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeregisterEcsClusterRequest {
#[serde(rename = "EcsClusterArn")]
pub ecs_cluster_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeregisterElasticIpRequest {
#[serde(rename = "ElasticIp")]
pub elastic_ip: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeregisterInstanceRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeregisterRdsDbInstanceRequest {
#[serde(rename = "RdsDbInstanceArn")]
pub rds_db_instance_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeregisterVolumeRequest {
#[serde(rename = "VolumeId")]
pub volume_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeAgentVersionsRequest {
#[serde(rename = "ConfigurationManager")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_manager: Option<StackConfigurationManager>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeAgentVersionsResult {
#[serde(rename = "AgentVersions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_versions: Option<Vec<AgentVersion>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeAppsRequest {
#[serde(rename = "AppIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_ids: Option<Vec<String>>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeAppsResult {
#[serde(rename = "Apps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub apps: Option<Vec<App>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeCommandsRequest {
#[serde(rename = "CommandIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub command_ids: Option<Vec<String>>,
#[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>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeCommandsResult {
#[serde(rename = "Commands")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commands: Option<Vec<Command>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeDeploymentsRequest {
#[serde(rename = "AppId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
#[serde(rename = "DeploymentIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_ids: Option<Vec<String>>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeDeploymentsResult {
#[serde(rename = "Deployments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployments: Option<Vec<Deployment>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeEcsClustersRequest {
#[serde(rename = "EcsClusterArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ecs_cluster_arns: Option<Vec<String>>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeEcsClustersResult {
#[serde(rename = "EcsClusters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ecs_clusters: Option<Vec<EcsCluster>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeElasticIpsRequest {
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "Ips")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ips: Option<Vec<String>>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeElasticIpsResult {
#[serde(rename = "ElasticIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elastic_ips: Option<Vec<ElasticIp>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeElasticLoadBalancersRequest {
#[serde(rename = "LayerIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_ids: Option<Vec<String>>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeElasticLoadBalancersResult {
#[serde(rename = "ElasticLoadBalancers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elastic_load_balancers: Option<Vec<ElasticLoadBalancer>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeInstancesRequest {
#[serde(rename = "InstanceIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_ids: Option<Vec<String>>,
#[serde(rename = "LayerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_id: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeInstancesResult {
#[serde(rename = "Instances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instances: Option<Vec<Instance>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeLayersRequest {
#[serde(rename = "LayerIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_ids: Option<Vec<String>>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeLayersResult {
#[serde(rename = "Layers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layers: Option<Vec<Layer>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeLoadBasedAutoScalingRequest {
#[serde(rename = "LayerIds")]
pub layer_ids: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeLoadBasedAutoScalingResult {
#[serde(rename = "LoadBasedAutoScalingConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub load_based_auto_scaling_configurations: Option<Vec<LoadBasedAutoScalingConfiguration>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeMyUserProfileResult {
#[serde(rename = "UserProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_profile: Option<SelfUserProfile>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeOperatingSystemsResponse {
#[serde(rename = "OperatingSystems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operating_systems: Option<Vec<OperatingSystem>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribePermissionsRequest {
#[serde(rename = "IamUserArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_user_arn: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribePermissionsResult {
#[serde(rename = "Permissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions: Option<Vec<Permission>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeRaidArraysRequest {
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "RaidArrayIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub raid_array_ids: Option<Vec<String>>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeRaidArraysResult {
#[serde(rename = "RaidArrays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub raid_arrays: Option<Vec<RaidArray>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeRdsDbInstancesRequest {
#[serde(rename = "RdsDbInstanceArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rds_db_instance_arns: Option<Vec<String>>,
#[serde(rename = "StackId")]
pub stack_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeRdsDbInstancesResult {
#[serde(rename = "RdsDbInstances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rds_db_instances: Option<Vec<RdsDbInstance>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeServiceErrorsRequest {
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "ServiceErrorIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_error_ids: Option<Vec<String>>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeServiceErrorsResult {
#[serde(rename = "ServiceErrors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_errors: Option<Vec<ServiceError>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeStackProvisioningParametersRequest {
#[serde(rename = "StackId")]
pub stack_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeStackProvisioningParametersResult {
#[serde(rename = "AgentInstallerUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_installer_url: Option<String>,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeStackSummaryRequest {
#[serde(rename = "StackId")]
pub stack_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeStackSummaryResult {
#[serde(rename = "StackSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_summary: Option<StackSummary>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeStacksRequest {
#[serde(rename = "StackIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_ids: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeStacksResult {
#[serde(rename = "Stacks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stacks: Option<Vec<Stack>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeTimeBasedAutoScalingRequest {
#[serde(rename = "InstanceIds")]
pub instance_ids: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeTimeBasedAutoScalingResult {
#[serde(rename = "TimeBasedAutoScalingConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub time_based_auto_scaling_configurations: Option<Vec<TimeBasedAutoScalingConfiguration>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeUserProfilesRequest {
#[serde(rename = "IamUserArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_user_arns: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeUserProfilesResult {
#[serde(rename = "UserProfiles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_profiles: Option<Vec<UserProfile>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeVolumesRequest {
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "RaidArrayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub raid_array_id: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
#[serde(rename = "VolumeIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_ids: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeVolumesResult {
#[serde(rename = "Volumes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volumes: Option<Vec<Volume>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DetachElasticLoadBalancerRequest {
#[serde(rename = "ElasticLoadBalancerName")]
pub elastic_load_balancer_name: String,
#[serde(rename = "LayerId")]
pub layer_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DisassociateElasticIpRequest {
#[serde(rename = "ElasticIp")]
pub elastic_ip: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EbsBlockDevice {
#[serde(rename = "DeleteOnTermination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_on_termination: Option<bool>,
#[serde(rename = "Iops")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iops: Option<i64>,
#[serde(rename = "SnapshotId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_id: Option<String>,
#[serde(rename = "VolumeSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_size: Option<i64>,
#[serde(rename = "VolumeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct EcsCluster {
#[serde(rename = "EcsClusterArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ecs_cluster_arn: Option<String>,
#[serde(rename = "EcsClusterName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ecs_cluster_name: Option<String>,
#[serde(rename = "RegisteredAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registered_at: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ElasticIp {
#[serde(rename = "Domain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain: Option<String>,
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "Ip")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ElasticLoadBalancer {
#[serde(rename = "AvailabilityZones")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zones: Option<Vec<String>>,
#[serde(rename = "DnsName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dns_name: Option<String>,
#[serde(rename = "Ec2InstanceIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_instance_ids: Option<Vec<String>>,
#[serde(rename = "ElasticLoadBalancerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elastic_load_balancer_name: Option<String>,
#[serde(rename = "LayerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_id: Option<String>,
#[serde(rename = "Region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
#[serde(rename = "SubnetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_ids: Option<Vec<String>>,
#[serde(rename = "VpcId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EnvironmentVariable {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Secure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secure: Option<bool>,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetHostnameSuggestionRequest {
#[serde(rename = "LayerId")]
pub layer_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetHostnameSuggestionResult {
#[serde(rename = "Hostname")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hostname: Option<String>,
#[serde(rename = "LayerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GrantAccessRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "ValidForInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub valid_for_in_minutes: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GrantAccessResult {
#[serde(rename = "TemporaryCredential")]
#[serde(skip_serializing_if = "Option::is_none")]
pub temporary_credential: Option<TemporaryCredential>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Instance {
#[serde(rename = "AgentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_version: Option<String>,
#[serde(rename = "AmiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ami_id: Option<String>,
#[serde(rename = "Architecture")]
#[serde(skip_serializing_if = "Option::is_none")]
pub architecture: Option<String>,
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "AutoScalingType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_type: Option<String>,
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "BlockDeviceMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub block_device_mappings: Option<Vec<BlockDeviceMapping>>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "EbsOptimized")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ebs_optimized: Option<bool>,
#[serde(rename = "Ec2InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_instance_id: Option<String>,
#[serde(rename = "EcsClusterArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ecs_cluster_arn: Option<String>,
#[serde(rename = "EcsContainerInstanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ecs_container_instance_arn: Option<String>,
#[serde(rename = "ElasticIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elastic_ip: Option<String>,
#[serde(rename = "Hostname")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hostname: Option<String>,
#[serde(rename = "InfrastructureClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub infrastructure_class: Option<String>,
#[serde(rename = "InstallUpdatesOnBoot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub install_updates_on_boot: Option<bool>,
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "InstanceProfileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_profile_arn: Option<String>,
#[serde(rename = "InstanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type: Option<String>,
#[serde(rename = "LastServiceErrorId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_service_error_id: Option<String>,
#[serde(rename = "LayerIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_ids: Option<Vec<String>>,
#[serde(rename = "Os")]
#[serde(skip_serializing_if = "Option::is_none")]
pub os: Option<String>,
#[serde(rename = "Platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "PrivateDns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_dns: Option<String>,
#[serde(rename = "PrivateIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_ip: Option<String>,
#[serde(rename = "PublicDns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_dns: Option<String>,
#[serde(rename = "PublicIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_ip: Option<String>,
#[serde(rename = "RegisteredBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registered_by: Option<String>,
#[serde(rename = "ReportedAgentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reported_agent_version: Option<String>,
#[serde(rename = "ReportedOs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reported_os: Option<ReportedOs>,
#[serde(rename = "RootDeviceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub root_device_type: Option<String>,
#[serde(rename = "RootDeviceVolumeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub root_device_volume_id: Option<String>,
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "SshHostDsaKeyFingerprint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_host_dsa_key_fingerprint: Option<String>,
#[serde(rename = "SshHostRsaKeyFingerprint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_host_rsa_key_fingerprint: Option<String>,
#[serde(rename = "SshKeyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_key_name: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "SubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
#[serde(rename = "Tenancy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tenancy: Option<String>,
#[serde(rename = "VirtualizationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtualization_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct InstanceIdentity {
#[serde(rename = "Document")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document: Option<String>,
#[serde(rename = "Signature")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signature: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct InstancesCount {
#[serde(rename = "Assigning")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assigning: Option<i64>,
#[serde(rename = "Booting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub booting: Option<i64>,
#[serde(rename = "ConnectionLost")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_lost: Option<i64>,
#[serde(rename = "Deregistering")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deregistering: Option<i64>,
#[serde(rename = "Online")]
#[serde(skip_serializing_if = "Option::is_none")]
pub online: Option<i64>,
#[serde(rename = "Pending")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pending: Option<i64>,
#[serde(rename = "Rebooting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rebooting: Option<i64>,
#[serde(rename = "Registered")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registered: Option<i64>,
#[serde(rename = "Registering")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registering: Option<i64>,
#[serde(rename = "Requested")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requested: Option<i64>,
#[serde(rename = "RunningSetup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub running_setup: Option<i64>,
#[serde(rename = "SetupFailed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_failed: Option<i64>,
#[serde(rename = "ShuttingDown")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shutting_down: Option<i64>,
#[serde(rename = "StartFailed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_failed: Option<i64>,
#[serde(rename = "StopFailed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stop_failed: Option<i64>,
#[serde(rename = "Stopped")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stopped: Option<i64>,
#[serde(rename = "Stopping")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stopping: Option<i64>,
#[serde(rename = "Terminated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub terminated: Option<i64>,
#[serde(rename = "Terminating")]
#[serde(skip_serializing_if = "Option::is_none")]
pub terminating: Option<i64>,
#[serde(rename = "Unassigning")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unassigning: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Layer {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "AutoAssignElasticIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_assign_elastic_ips: Option<bool>,
#[serde(rename = "AutoAssignPublicIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_assign_public_ips: Option<bool>,
#[serde(rename = "CloudWatchLogsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logs_configuration: Option<CloudWatchLogsConfiguration>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "CustomInstanceProfileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_instance_profile_arn: Option<String>,
#[serde(rename = "CustomJson")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_json: Option<String>,
#[serde(rename = "CustomRecipes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_recipes: Option<Recipes>,
#[serde(rename = "CustomSecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_security_group_ids: Option<Vec<String>>,
#[serde(rename = "DefaultRecipes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_recipes: Option<Recipes>,
#[serde(rename = "DefaultSecurityGroupNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_security_group_names: Option<Vec<String>>,
#[serde(rename = "EnableAutoHealing")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_auto_healing: Option<bool>,
#[serde(rename = "InstallUpdatesOnBoot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub install_updates_on_boot: Option<bool>,
#[serde(rename = "LayerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_id: Option<String>,
#[serde(rename = "LifecycleEventConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_event_configuration: Option<LifecycleEventConfiguration>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Packages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packages: Option<Vec<String>>,
#[serde(rename = "Shortname")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shortname: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "UseEbsOptimizedInstances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_ebs_optimized_instances: Option<bool>,
#[serde(rename = "VolumeConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_configurations: Option<Vec<VolumeConfiguration>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LifecycleEventConfiguration {
#[serde(rename = "Shutdown")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shutdown: Option<ShutdownEventConfiguration>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListTagsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListTagsResult {
#[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<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct LoadBasedAutoScalingConfiguration {
#[serde(rename = "DownScaling")]
#[serde(skip_serializing_if = "Option::is_none")]
pub down_scaling: Option<AutoScalingThresholds>,
#[serde(rename = "Enable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable: Option<bool>,
#[serde(rename = "LayerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_id: Option<String>,
#[serde(rename = "UpScaling")]
#[serde(skip_serializing_if = "Option::is_none")]
pub up_scaling: Option<AutoScalingThresholds>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct OperatingSystem {
#[serde(rename = "ConfigurationManagers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_managers: Option<Vec<OperatingSystemConfigurationManager>>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ReportedName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reported_name: Option<String>,
#[serde(rename = "ReportedVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reported_version: Option<String>,
#[serde(rename = "Supported")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supported: Option<bool>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct OperatingSystemConfigurationManager {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Permission {
#[serde(rename = "AllowSsh")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_ssh: Option<bool>,
#[serde(rename = "AllowSudo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_sudo: Option<bool>,
#[serde(rename = "IamUserArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_user_arn: Option<String>,
#[serde(rename = "Level")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RaidArray {
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "Device")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device: Option<String>,
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "Iops")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iops: Option<i64>,
#[serde(rename = "MountPoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mount_point: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "NumberOfDisks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_disks: Option<i64>,
#[serde(rename = "RaidArrayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub raid_array_id: Option<String>,
#[serde(rename = "RaidLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub raid_level: Option<i64>,
#[serde(rename = "Size")]
#[serde(skip_serializing_if = "Option::is_none")]
pub size: Option<i64>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
#[serde(rename = "VolumeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RdsDbInstance {
#[serde(rename = "Address")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address: Option<String>,
#[serde(rename = "DbInstanceIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub db_instance_identifier: Option<String>,
#[serde(rename = "DbPassword")]
#[serde(skip_serializing_if = "Option::is_none")]
pub db_password: Option<String>,
#[serde(rename = "DbUser")]
#[serde(skip_serializing_if = "Option::is_none")]
pub db_user: Option<String>,
#[serde(rename = "Engine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine: Option<String>,
#[serde(rename = "MissingOnRds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub missing_on_rds: Option<bool>,
#[serde(rename = "RdsDbInstanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rds_db_instance_arn: Option<String>,
#[serde(rename = "Region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RebootInstanceRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Recipes {
#[serde(rename = "Configure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configure: Option<Vec<String>>,
#[serde(rename = "Deploy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deploy: Option<Vec<String>>,
#[serde(rename = "Setup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub setup: Option<Vec<String>>,
#[serde(rename = "Shutdown")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shutdown: Option<Vec<String>>,
#[serde(rename = "Undeploy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub undeploy: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RegisterEcsClusterRequest {
#[serde(rename = "EcsClusterArn")]
pub ecs_cluster_arn: String,
#[serde(rename = "StackId")]
pub stack_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RegisterEcsClusterResult {
#[serde(rename = "EcsClusterArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ecs_cluster_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RegisterElasticIpRequest {
#[serde(rename = "ElasticIp")]
pub elastic_ip: String,
#[serde(rename = "StackId")]
pub stack_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RegisterElasticIpResult {
#[serde(rename = "ElasticIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elastic_ip: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RegisterInstanceRequest {
#[serde(rename = "Hostname")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hostname: Option<String>,
#[serde(rename = "InstanceIdentity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_identity: Option<InstanceIdentity>,
#[serde(rename = "PrivateIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_ip: Option<String>,
#[serde(rename = "PublicIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_ip: Option<String>,
#[serde(rename = "RsaPublicKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rsa_public_key: Option<String>,
#[serde(rename = "RsaPublicKeyFingerprint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rsa_public_key_fingerprint: Option<String>,
#[serde(rename = "StackId")]
pub stack_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RegisterInstanceResult {
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RegisterRdsDbInstanceRequest {
#[serde(rename = "DbPassword")]
pub db_password: String,
#[serde(rename = "DbUser")]
pub db_user: String,
#[serde(rename = "RdsDbInstanceArn")]
pub rds_db_instance_arn: String,
#[serde(rename = "StackId")]
pub stack_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RegisterVolumeRequest {
#[serde(rename = "Ec2VolumeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_volume_id: Option<String>,
#[serde(rename = "StackId")]
pub stack_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RegisterVolumeResult {
#[serde(rename = "VolumeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ReportedOs {
#[serde(rename = "Family")]
#[serde(skip_serializing_if = "Option::is_none")]
pub family: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct SelfUserProfile {
#[serde(rename = "IamUserArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_user_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SshPublicKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_public_key: Option<String>,
#[serde(rename = "SshUsername")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_username: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ServiceError {
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "ServiceErrorId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_error_id: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct SetLoadBasedAutoScalingRequest {
#[serde(rename = "DownScaling")]
#[serde(skip_serializing_if = "Option::is_none")]
pub down_scaling: Option<AutoScalingThresholds>,
#[serde(rename = "Enable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable: Option<bool>,
#[serde(rename = "LayerId")]
pub layer_id: String,
#[serde(rename = "UpScaling")]
#[serde(skip_serializing_if = "Option::is_none")]
pub up_scaling: Option<AutoScalingThresholds>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct SetPermissionRequest {
#[serde(rename = "AllowSsh")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_ssh: Option<bool>,
#[serde(rename = "AllowSudo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_sudo: Option<bool>,
#[serde(rename = "IamUserArn")]
pub iam_user_arn: String,
#[serde(rename = "Level")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level: Option<String>,
#[serde(rename = "StackId")]
pub stack_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct SetTimeBasedAutoScalingRequest {
#[serde(rename = "AutoScalingSchedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_schedule: Option<WeeklyAutoScalingSchedule>,
#[serde(rename = "InstanceId")]
pub instance_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ShutdownEventConfiguration {
#[serde(rename = "DelayUntilElbConnectionsDrained")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delay_until_elb_connections_drained: Option<bool>,
#[serde(rename = "ExecutionTimeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution_timeout: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Source {
#[serde(rename = "Password")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password: Option<String>,
#[serde(rename = "Revision")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision: Option<String>,
#[serde(rename = "SshKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_key: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "Url")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
#[serde(rename = "Username")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SslConfiguration {
#[serde(rename = "Certificate")]
pub certificate: String,
#[serde(rename = "Chain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub chain: Option<String>,
#[serde(rename = "PrivateKey")]
pub private_key: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Stack {
#[serde(rename = "AgentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_version: Option<String>,
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ChefConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub chef_configuration: Option<ChefConfiguration>,
#[serde(rename = "ConfigurationManager")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_manager: Option<StackConfigurationManager>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "CustomCookbooksSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_cookbooks_source: Option<Source>,
#[serde(rename = "CustomJson")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_json: Option<String>,
#[serde(rename = "DefaultAvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_availability_zone: Option<String>,
#[serde(rename = "DefaultInstanceProfileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_instance_profile_arn: Option<String>,
#[serde(rename = "DefaultOs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_os: Option<String>,
#[serde(rename = "DefaultRootDeviceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_root_device_type: Option<String>,
#[serde(rename = "DefaultSshKeyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_ssh_key_name: Option<String>,
#[serde(rename = "DefaultSubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_subnet_id: Option<String>,
#[serde(rename = "HostnameTheme")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hostname_theme: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "ServiceRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_role_arn: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
#[serde(rename = "UseCustomCookbooks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_custom_cookbooks: Option<bool>,
#[serde(rename = "UseOpsworksSecurityGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_opsworks_security_groups: Option<bool>,
#[serde(rename = "VpcId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StackConfigurationManager {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StackSummary {
#[serde(rename = "AppsCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub apps_count: Option<i64>,
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "InstancesCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instances_count: Option<InstancesCount>,
#[serde(rename = "LayersCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layers_count: Option<i64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartInstanceRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartStackRequest {
#[serde(rename = "StackId")]
pub stack_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StopInstanceRequest {
#[serde(rename = "Force")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force: Option<bool>,
#[serde(rename = "InstanceId")]
pub instance_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StopStackRequest {
#[serde(rename = "StackId")]
pub stack_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct TemporaryCredential {
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "Password")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password: Option<String>,
#[serde(rename = "Username")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
#[serde(rename = "ValidForInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub valid_for_in_minutes: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct TimeBasedAutoScalingConfiguration {
#[serde(rename = "AutoScalingSchedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_schedule: Option<WeeklyAutoScalingSchedule>,
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UnassignInstanceRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UnassignVolumeRequest {
#[serde(rename = "VolumeId")]
pub volume_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateAppRequest {
#[serde(rename = "AppId")]
pub app_id: String,
#[serde(rename = "AppSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_source: Option<Source>,
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "DataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<Vec<DataSource>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Domains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domains: Option<Vec<String>>,
#[serde(rename = "EnableSsl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_ssl: Option<bool>,
#[serde(rename = "Environment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<Vec<EnvironmentVariable>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SslConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_configuration: Option<SslConfiguration>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateElasticIpRequest {
#[serde(rename = "ElasticIp")]
pub elastic_ip: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateInstanceRequest {
#[serde(rename = "AgentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_version: Option<String>,
#[serde(rename = "AmiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ami_id: Option<String>,
#[serde(rename = "Architecture")]
#[serde(skip_serializing_if = "Option::is_none")]
pub architecture: Option<String>,
#[serde(rename = "AutoScalingType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_type: Option<String>,
#[serde(rename = "EbsOptimized")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ebs_optimized: Option<bool>,
#[serde(rename = "Hostname")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hostname: Option<String>,
#[serde(rename = "InstallUpdatesOnBoot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub install_updates_on_boot: Option<bool>,
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "InstanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type: Option<String>,
#[serde(rename = "LayerIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_ids: Option<Vec<String>>,
#[serde(rename = "Os")]
#[serde(skip_serializing_if = "Option::is_none")]
pub os: Option<String>,
#[serde(rename = "SshKeyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_key_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateLayerRequest {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "AutoAssignElasticIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_assign_elastic_ips: Option<bool>,
#[serde(rename = "AutoAssignPublicIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_assign_public_ips: Option<bool>,
#[serde(rename = "CloudWatchLogsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logs_configuration: Option<CloudWatchLogsConfiguration>,
#[serde(rename = "CustomInstanceProfileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_instance_profile_arn: Option<String>,
#[serde(rename = "CustomJson")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_json: Option<String>,
#[serde(rename = "CustomRecipes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_recipes: Option<Recipes>,
#[serde(rename = "CustomSecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_security_group_ids: Option<Vec<String>>,
#[serde(rename = "EnableAutoHealing")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_auto_healing: Option<bool>,
#[serde(rename = "InstallUpdatesOnBoot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub install_updates_on_boot: Option<bool>,
#[serde(rename = "LayerId")]
pub layer_id: String,
#[serde(rename = "LifecycleEventConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_event_configuration: Option<LifecycleEventConfiguration>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Packages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub packages: Option<Vec<String>>,
#[serde(rename = "Shortname")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shortname: Option<String>,
#[serde(rename = "UseEbsOptimizedInstances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_ebs_optimized_instances: Option<bool>,
#[serde(rename = "VolumeConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_configurations: Option<Vec<VolumeConfiguration>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateMyUserProfileRequest {
#[serde(rename = "SshPublicKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_public_key: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateRdsDbInstanceRequest {
#[serde(rename = "DbPassword")]
#[serde(skip_serializing_if = "Option::is_none")]
pub db_password: Option<String>,
#[serde(rename = "DbUser")]
#[serde(skip_serializing_if = "Option::is_none")]
pub db_user: Option<String>,
#[serde(rename = "RdsDbInstanceArn")]
pub rds_db_instance_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateStackRequest {
#[serde(rename = "AgentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_version: Option<String>,
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ChefConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub chef_configuration: Option<ChefConfiguration>,
#[serde(rename = "ConfigurationManager")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_manager: Option<StackConfigurationManager>,
#[serde(rename = "CustomCookbooksSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_cookbooks_source: Option<Source>,
#[serde(rename = "CustomJson")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_json: Option<String>,
#[serde(rename = "DefaultAvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_availability_zone: Option<String>,
#[serde(rename = "DefaultInstanceProfileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_instance_profile_arn: Option<String>,
#[serde(rename = "DefaultOs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_os: Option<String>,
#[serde(rename = "DefaultRootDeviceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_root_device_type: Option<String>,
#[serde(rename = "DefaultSshKeyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_ssh_key_name: Option<String>,
#[serde(rename = "DefaultSubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_subnet_id: Option<String>,
#[serde(rename = "HostnameTheme")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hostname_theme: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ServiceRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_role_arn: Option<String>,
#[serde(rename = "StackId")]
pub stack_id: String,
#[serde(rename = "UseCustomCookbooks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_custom_cookbooks: Option<bool>,
#[serde(rename = "UseOpsworksSecurityGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_opsworks_security_groups: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateUserProfileRequest {
#[serde(rename = "AllowSelfManagement")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_self_management: Option<bool>,
#[serde(rename = "IamUserArn")]
pub iam_user_arn: String,
#[serde(rename = "SshPublicKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_public_key: Option<String>,
#[serde(rename = "SshUsername")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_username: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateVolumeRequest {
#[serde(rename = "MountPoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mount_point: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "VolumeId")]
pub volume_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UserProfile {
#[serde(rename = "AllowSelfManagement")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_self_management: Option<bool>,
#[serde(rename = "IamUserArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_user_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SshPublicKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_public_key: Option<String>,
#[serde(rename = "SshUsername")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_username: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Volume {
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "Device")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device: Option<String>,
#[serde(rename = "Ec2VolumeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_volume_id: Option<String>,
#[serde(rename = "Encrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encrypted: Option<bool>,
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "Iops")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iops: Option<i64>,
#[serde(rename = "MountPoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mount_point: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "RaidArrayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub raid_array_id: Option<String>,
#[serde(rename = "Region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "Size")]
#[serde(skip_serializing_if = "Option::is_none")]
pub size: Option<i64>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "VolumeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_id: Option<String>,
#[serde(rename = "VolumeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VolumeConfiguration {
#[serde(rename = "Encrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encrypted: Option<bool>,
#[serde(rename = "Iops")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iops: Option<i64>,
#[serde(rename = "MountPoint")]
pub mount_point: String,
#[serde(rename = "NumberOfDisks")]
pub number_of_disks: i64,
#[serde(rename = "RaidLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub raid_level: Option<i64>,
#[serde(rename = "Size")]
pub size: i64,
#[serde(rename = "VolumeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WeeklyAutoScalingSchedule {
#[serde(rename = "Friday")]
#[serde(skip_serializing_if = "Option::is_none")]
pub friday: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Monday")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monday: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Saturday")]
#[serde(skip_serializing_if = "Option::is_none")]
pub saturday: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Sunday")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sunday: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Thursday")]
#[serde(skip_serializing_if = "Option::is_none")]
pub thursday: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Tuesday")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tuesday: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Wednesday")]
#[serde(skip_serializing_if = "Option::is_none")]
pub wednesday: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Debug, PartialEq)]
pub enum AssignInstanceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AssignInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> AssignInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return AssignInstanceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return AssignInstanceError::Validation(error_message.to_string());
}
_ => {}
}
}
return AssignInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AssignInstanceError {
fn from(err: serde_json::error::Error) -> AssignInstanceError {
AssignInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AssignInstanceError {
fn from(err: CredentialsError) -> AssignInstanceError {
AssignInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for AssignInstanceError {
fn from(err: HttpDispatchError) -> AssignInstanceError {
AssignInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for AssignInstanceError {
fn from(err: io::Error) -> AssignInstanceError {
AssignInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AssignInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssignInstanceError {
fn description(&self) -> &str {
match *self {
AssignInstanceError::ResourceNotFound(ref cause) => cause,
AssignInstanceError::Validation(ref cause) => cause,
AssignInstanceError::Credentials(ref err) => err.description(),
AssignInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
AssignInstanceError::ParseError(ref cause) => cause,
AssignInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AssignVolumeError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AssignVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> AssignVolumeError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return AssignVolumeError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return AssignVolumeError::Validation(error_message.to_string());
}
_ => {}
}
}
return AssignVolumeError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AssignVolumeError {
fn from(err: serde_json::error::Error) -> AssignVolumeError {
AssignVolumeError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AssignVolumeError {
fn from(err: CredentialsError) -> AssignVolumeError {
AssignVolumeError::Credentials(err)
}
}
impl From<HttpDispatchError> for AssignVolumeError {
fn from(err: HttpDispatchError) -> AssignVolumeError {
AssignVolumeError::HttpDispatch(err)
}
}
impl From<io::Error> for AssignVolumeError {
fn from(err: io::Error) -> AssignVolumeError {
AssignVolumeError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AssignVolumeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssignVolumeError {
fn description(&self) -> &str {
match *self {
AssignVolumeError::ResourceNotFound(ref cause) => cause,
AssignVolumeError::Validation(ref cause) => cause,
AssignVolumeError::Credentials(ref err) => err.description(),
AssignVolumeError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
AssignVolumeError::ParseError(ref cause) => cause,
AssignVolumeError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AssociateElasticIpError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AssociateElasticIpError {
pub fn from_response(res: BufferedHttpResponse) -> AssociateElasticIpError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return AssociateElasticIpError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return AssociateElasticIpError::Validation(error_message.to_string());
}
_ => {}
}
}
return AssociateElasticIpError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AssociateElasticIpError {
fn from(err: serde_json::error::Error) -> AssociateElasticIpError {
AssociateElasticIpError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AssociateElasticIpError {
fn from(err: CredentialsError) -> AssociateElasticIpError {
AssociateElasticIpError::Credentials(err)
}
}
impl From<HttpDispatchError> for AssociateElasticIpError {
fn from(err: HttpDispatchError) -> AssociateElasticIpError {
AssociateElasticIpError::HttpDispatch(err)
}
}
impl From<io::Error> for AssociateElasticIpError {
fn from(err: io::Error) -> AssociateElasticIpError {
AssociateElasticIpError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AssociateElasticIpError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateElasticIpError {
fn description(&self) -> &str {
match *self {
AssociateElasticIpError::ResourceNotFound(ref cause) => cause,
AssociateElasticIpError::Validation(ref cause) => cause,
AssociateElasticIpError::Credentials(ref err) => err.description(),
AssociateElasticIpError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AssociateElasticIpError::ParseError(ref cause) => cause,
AssociateElasticIpError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AttachElasticLoadBalancerError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AttachElasticLoadBalancerError {
pub fn from_response(res: BufferedHttpResponse) -> AttachElasticLoadBalancerError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return AttachElasticLoadBalancerError::ResourceNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return AttachElasticLoadBalancerError::Validation(error_message.to_string());
}
_ => {}
}
}
return AttachElasticLoadBalancerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AttachElasticLoadBalancerError {
fn from(err: serde_json::error::Error) -> AttachElasticLoadBalancerError {
AttachElasticLoadBalancerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AttachElasticLoadBalancerError {
fn from(err: CredentialsError) -> AttachElasticLoadBalancerError {
AttachElasticLoadBalancerError::Credentials(err)
}
}
impl From<HttpDispatchError> for AttachElasticLoadBalancerError {
fn from(err: HttpDispatchError) -> AttachElasticLoadBalancerError {
AttachElasticLoadBalancerError::HttpDispatch(err)
}
}
impl From<io::Error> for AttachElasticLoadBalancerError {
fn from(err: io::Error) -> AttachElasticLoadBalancerError {
AttachElasticLoadBalancerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AttachElasticLoadBalancerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AttachElasticLoadBalancerError {
fn description(&self) -> &str {
match *self {
AttachElasticLoadBalancerError::ResourceNotFound(ref cause) => cause,
AttachElasticLoadBalancerError::Validation(ref cause) => cause,
AttachElasticLoadBalancerError::Credentials(ref err) => err.description(),
AttachElasticLoadBalancerError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AttachElasticLoadBalancerError::ParseError(ref cause) => cause,
AttachElasticLoadBalancerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CloneStackError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CloneStackError {
pub fn from_response(res: BufferedHttpResponse) -> CloneStackError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return CloneStackError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return CloneStackError::Validation(error_message.to_string());
}
_ => {}
}
}
return CloneStackError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CloneStackError {
fn from(err: serde_json::error::Error) -> CloneStackError {
CloneStackError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CloneStackError {
fn from(err: CredentialsError) -> CloneStackError {
CloneStackError::Credentials(err)
}
}
impl From<HttpDispatchError> for CloneStackError {
fn from(err: HttpDispatchError) -> CloneStackError {
CloneStackError::HttpDispatch(err)
}
}
impl From<io::Error> for CloneStackError {
fn from(err: io::Error) -> CloneStackError {
CloneStackError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CloneStackError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CloneStackError {
fn description(&self) -> &str {
match *self {
CloneStackError::ResourceNotFound(ref cause) => cause,
CloneStackError::Validation(ref cause) => cause,
CloneStackError::Credentials(ref err) => err.description(),
CloneStackError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CloneStackError::ParseError(ref cause) => cause,
CloneStackError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateAppError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateAppError {
pub fn from_response(res: BufferedHttpResponse) -> CreateAppError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return CreateAppError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return CreateAppError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateAppError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateAppError {
fn from(err: serde_json::error::Error) -> CreateAppError {
CreateAppError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateAppError {
fn from(err: CredentialsError) -> CreateAppError {
CreateAppError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateAppError {
fn from(err: HttpDispatchError) -> CreateAppError {
CreateAppError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateAppError {
fn from(err: io::Error) -> CreateAppError {
CreateAppError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateAppError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateAppError {
fn description(&self) -> &str {
match *self {
CreateAppError::ResourceNotFound(ref cause) => cause,
CreateAppError::Validation(ref cause) => cause,
CreateAppError::Credentials(ref err) => err.description(),
CreateAppError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateAppError::ParseError(ref cause) => cause,
CreateAppError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDeploymentError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDeploymentError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return CreateDeploymentError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return CreateDeploymentError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateDeploymentError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateDeploymentError {
fn from(err: serde_json::error::Error) -> CreateDeploymentError {
CreateDeploymentError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateDeploymentError {
fn from(err: CredentialsError) -> CreateDeploymentError {
CreateDeploymentError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDeploymentError {
fn from(err: HttpDispatchError) -> CreateDeploymentError {
CreateDeploymentError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDeploymentError {
fn from(err: io::Error) -> CreateDeploymentError {
CreateDeploymentError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDeploymentError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDeploymentError {
fn description(&self) -> &str {
match *self {
CreateDeploymentError::ResourceNotFound(ref cause) => cause,
CreateDeploymentError::Validation(ref cause) => cause,
CreateDeploymentError::Credentials(ref err) => err.description(),
CreateDeploymentError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateDeploymentError::ParseError(ref cause) => cause,
CreateDeploymentError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateInstanceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> CreateInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return CreateInstanceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return CreateInstanceError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateInstanceError {
fn from(err: serde_json::error::Error) -> CreateInstanceError {
CreateInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateInstanceError {
fn from(err: CredentialsError) -> CreateInstanceError {
CreateInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateInstanceError {
fn from(err: HttpDispatchError) -> CreateInstanceError {
CreateInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateInstanceError {
fn from(err: io::Error) -> CreateInstanceError {
CreateInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateInstanceError {
fn description(&self) -> &str {
match *self {
CreateInstanceError::ResourceNotFound(ref cause) => cause,
CreateInstanceError::Validation(ref cause) => cause,
CreateInstanceError::Credentials(ref err) => err.description(),
CreateInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateInstanceError::ParseError(ref cause) => cause,
CreateInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateLayerError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateLayerError {
pub fn from_response(res: BufferedHttpResponse) -> CreateLayerError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return CreateLayerError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return CreateLayerError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateLayerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateLayerError {
fn from(err: serde_json::error::Error) -> CreateLayerError {
CreateLayerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateLayerError {
fn from(err: CredentialsError) -> CreateLayerError {
CreateLayerError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateLayerError {
fn from(err: HttpDispatchError) -> CreateLayerError {
CreateLayerError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateLayerError {
fn from(err: io::Error) -> CreateLayerError {
CreateLayerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateLayerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateLayerError {
fn description(&self) -> &str {
match *self {
CreateLayerError::ResourceNotFound(ref cause) => cause,
CreateLayerError::Validation(ref cause) => cause,
CreateLayerError::Credentials(ref err) => err.description(),
CreateLayerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateLayerError::ParseError(ref cause) => cause,
CreateLayerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateStackError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateStackError {
pub fn from_response(res: BufferedHttpResponse) -> CreateStackError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ValidationException" => {
return CreateStackError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateStackError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateStackError {
fn from(err: serde_json::error::Error) -> CreateStackError {
CreateStackError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateStackError {
fn from(err: CredentialsError) -> CreateStackError {
CreateStackError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateStackError {
fn from(err: HttpDispatchError) -> CreateStackError {
CreateStackError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateStackError {
fn from(err: io::Error) -> CreateStackError {
CreateStackError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateStackError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateStackError {
fn description(&self) -> &str {
match *self {
CreateStackError::Validation(ref cause) => cause,
CreateStackError::Credentials(ref err) => err.description(),
CreateStackError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateStackError::ParseError(ref cause) => cause,
CreateStackError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateUserProfileError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateUserProfileError {
pub fn from_response(res: BufferedHttpResponse) -> CreateUserProfileError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ValidationException" => {
return CreateUserProfileError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateUserProfileError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateUserProfileError {
fn from(err: serde_json::error::Error) -> CreateUserProfileError {
CreateUserProfileError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateUserProfileError {
fn from(err: CredentialsError) -> CreateUserProfileError {
CreateUserProfileError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateUserProfileError {
fn from(err: HttpDispatchError) -> CreateUserProfileError {
CreateUserProfileError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateUserProfileError {
fn from(err: io::Error) -> CreateUserProfileError {
CreateUserProfileError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateUserProfileError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateUserProfileError {
fn description(&self) -> &str {
match *self {
CreateUserProfileError::Validation(ref cause) => cause,
CreateUserProfileError::Credentials(ref err) => err.description(),
CreateUserProfileError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateUserProfileError::ParseError(ref cause) => cause,
CreateUserProfileError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteAppError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteAppError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteAppError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DeleteAppError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DeleteAppError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteAppError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteAppError {
fn from(err: serde_json::error::Error) -> DeleteAppError {
DeleteAppError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteAppError {
fn from(err: CredentialsError) -> DeleteAppError {
DeleteAppError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteAppError {
fn from(err: HttpDispatchError) -> DeleteAppError {
DeleteAppError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteAppError {
fn from(err: io::Error) -> DeleteAppError {
DeleteAppError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteAppError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteAppError {
fn description(&self) -> &str {
match *self {
DeleteAppError::ResourceNotFound(ref cause) => cause,
DeleteAppError::Validation(ref cause) => cause,
DeleteAppError::Credentials(ref err) => err.description(),
DeleteAppError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteAppError::ParseError(ref cause) => cause,
DeleteAppError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteInstanceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DeleteInstanceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DeleteInstanceError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteInstanceError {
fn from(err: serde_json::error::Error) -> DeleteInstanceError {
DeleteInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteInstanceError {
fn from(err: CredentialsError) -> DeleteInstanceError {
DeleteInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteInstanceError {
fn from(err: HttpDispatchError) -> DeleteInstanceError {
DeleteInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteInstanceError {
fn from(err: io::Error) -> DeleteInstanceError {
DeleteInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteInstanceError {
fn description(&self) -> &str {
match *self {
DeleteInstanceError::ResourceNotFound(ref cause) => cause,
DeleteInstanceError::Validation(ref cause) => cause,
DeleteInstanceError::Credentials(ref err) => err.description(),
DeleteInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteInstanceError::ParseError(ref cause) => cause,
DeleteInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteLayerError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteLayerError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteLayerError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DeleteLayerError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DeleteLayerError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteLayerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteLayerError {
fn from(err: serde_json::error::Error) -> DeleteLayerError {
DeleteLayerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteLayerError {
fn from(err: CredentialsError) -> DeleteLayerError {
DeleteLayerError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteLayerError {
fn from(err: HttpDispatchError) -> DeleteLayerError {
DeleteLayerError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteLayerError {
fn from(err: io::Error) -> DeleteLayerError {
DeleteLayerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteLayerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteLayerError {
fn description(&self) -> &str {
match *self {
DeleteLayerError::ResourceNotFound(ref cause) => cause,
DeleteLayerError::Validation(ref cause) => cause,
DeleteLayerError::Credentials(ref err) => err.description(),
DeleteLayerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteLayerError::ParseError(ref cause) => cause,
DeleteLayerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteStackError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteStackError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteStackError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DeleteStackError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DeleteStackError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteStackError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteStackError {
fn from(err: serde_json::error::Error) -> DeleteStackError {
DeleteStackError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteStackError {
fn from(err: CredentialsError) -> DeleteStackError {
DeleteStackError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteStackError {
fn from(err: HttpDispatchError) -> DeleteStackError {
DeleteStackError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteStackError {
fn from(err: io::Error) -> DeleteStackError {
DeleteStackError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteStackError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteStackError {
fn description(&self) -> &str {
match *self {
DeleteStackError::ResourceNotFound(ref cause) => cause,
DeleteStackError::Validation(ref cause) => cause,
DeleteStackError::Credentials(ref err) => err.description(),
DeleteStackError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteStackError::ParseError(ref cause) => cause,
DeleteStackError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteUserProfileError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteUserProfileError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteUserProfileError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DeleteUserProfileError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DeleteUserProfileError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteUserProfileError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteUserProfileError {
fn from(err: serde_json::error::Error) -> DeleteUserProfileError {
DeleteUserProfileError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteUserProfileError {
fn from(err: CredentialsError) -> DeleteUserProfileError {
DeleteUserProfileError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteUserProfileError {
fn from(err: HttpDispatchError) -> DeleteUserProfileError {
DeleteUserProfileError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteUserProfileError {
fn from(err: io::Error) -> DeleteUserProfileError {
DeleteUserProfileError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteUserProfileError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteUserProfileError {
fn description(&self) -> &str {
match *self {
DeleteUserProfileError::ResourceNotFound(ref cause) => cause,
DeleteUserProfileError::Validation(ref cause) => cause,
DeleteUserProfileError::Credentials(ref err) => err.description(),
DeleteUserProfileError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteUserProfileError::ParseError(ref cause) => cause,
DeleteUserProfileError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeregisterEcsClusterError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeregisterEcsClusterError {
pub fn from_response(res: BufferedHttpResponse) -> DeregisterEcsClusterError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DeregisterEcsClusterError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DeregisterEcsClusterError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeregisterEcsClusterError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeregisterEcsClusterError {
fn from(err: serde_json::error::Error) -> DeregisterEcsClusterError {
DeregisterEcsClusterError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeregisterEcsClusterError {
fn from(err: CredentialsError) -> DeregisterEcsClusterError {
DeregisterEcsClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeregisterEcsClusterError {
fn from(err: HttpDispatchError) -> DeregisterEcsClusterError {
DeregisterEcsClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for DeregisterEcsClusterError {
fn from(err: io::Error) -> DeregisterEcsClusterError {
DeregisterEcsClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeregisterEcsClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeregisterEcsClusterError {
fn description(&self) -> &str {
match *self {
DeregisterEcsClusterError::ResourceNotFound(ref cause) => cause,
DeregisterEcsClusterError::Validation(ref cause) => cause,
DeregisterEcsClusterError::Credentials(ref err) => err.description(),
DeregisterEcsClusterError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeregisterEcsClusterError::ParseError(ref cause) => cause,
DeregisterEcsClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeregisterElasticIpError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeregisterElasticIpError {
pub fn from_response(res: BufferedHttpResponse) -> DeregisterElasticIpError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DeregisterElasticIpError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DeregisterElasticIpError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeregisterElasticIpError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeregisterElasticIpError {
fn from(err: serde_json::error::Error) -> DeregisterElasticIpError {
DeregisterElasticIpError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeregisterElasticIpError {
fn from(err: CredentialsError) -> DeregisterElasticIpError {
DeregisterElasticIpError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeregisterElasticIpError {
fn from(err: HttpDispatchError) -> DeregisterElasticIpError {
DeregisterElasticIpError::HttpDispatch(err)
}
}
impl From<io::Error> for DeregisterElasticIpError {
fn from(err: io::Error) -> DeregisterElasticIpError {
DeregisterElasticIpError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeregisterElasticIpError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeregisterElasticIpError {
fn description(&self) -> &str {
match *self {
DeregisterElasticIpError::ResourceNotFound(ref cause) => cause,
DeregisterElasticIpError::Validation(ref cause) => cause,
DeregisterElasticIpError::Credentials(ref err) => err.description(),
DeregisterElasticIpError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeregisterElasticIpError::ParseError(ref cause) => cause,
DeregisterElasticIpError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeregisterInstanceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeregisterInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> DeregisterInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DeregisterInstanceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DeregisterInstanceError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeregisterInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeregisterInstanceError {
fn from(err: serde_json::error::Error) -> DeregisterInstanceError {
DeregisterInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeregisterInstanceError {
fn from(err: CredentialsError) -> DeregisterInstanceError {
DeregisterInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeregisterInstanceError {
fn from(err: HttpDispatchError) -> DeregisterInstanceError {
DeregisterInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for DeregisterInstanceError {
fn from(err: io::Error) -> DeregisterInstanceError {
DeregisterInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeregisterInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeregisterInstanceError {
fn description(&self) -> &str {
match *self {
DeregisterInstanceError::ResourceNotFound(ref cause) => cause,
DeregisterInstanceError::Validation(ref cause) => cause,
DeregisterInstanceError::Credentials(ref err) => err.description(),
DeregisterInstanceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeregisterInstanceError::ParseError(ref cause) => cause,
DeregisterInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeregisterRdsDbInstanceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeregisterRdsDbInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> DeregisterRdsDbInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DeregisterRdsDbInstanceError::ResourceNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return DeregisterRdsDbInstanceError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeregisterRdsDbInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeregisterRdsDbInstanceError {
fn from(err: serde_json::error::Error) -> DeregisterRdsDbInstanceError {
DeregisterRdsDbInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeregisterRdsDbInstanceError {
fn from(err: CredentialsError) -> DeregisterRdsDbInstanceError {
DeregisterRdsDbInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeregisterRdsDbInstanceError {
fn from(err: HttpDispatchError) -> DeregisterRdsDbInstanceError {
DeregisterRdsDbInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for DeregisterRdsDbInstanceError {
fn from(err: io::Error) -> DeregisterRdsDbInstanceError {
DeregisterRdsDbInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeregisterRdsDbInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeregisterRdsDbInstanceError {
fn description(&self) -> &str {
match *self {
DeregisterRdsDbInstanceError::ResourceNotFound(ref cause) => cause,
DeregisterRdsDbInstanceError::Validation(ref cause) => cause,
DeregisterRdsDbInstanceError::Credentials(ref err) => err.description(),
DeregisterRdsDbInstanceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeregisterRdsDbInstanceError::ParseError(ref cause) => cause,
DeregisterRdsDbInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeregisterVolumeError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeregisterVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> DeregisterVolumeError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DeregisterVolumeError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DeregisterVolumeError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeregisterVolumeError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeregisterVolumeError {
fn from(err: serde_json::error::Error) -> DeregisterVolumeError {
DeregisterVolumeError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeregisterVolumeError {
fn from(err: CredentialsError) -> DeregisterVolumeError {
DeregisterVolumeError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeregisterVolumeError {
fn from(err: HttpDispatchError) -> DeregisterVolumeError {
DeregisterVolumeError::HttpDispatch(err)
}
}
impl From<io::Error> for DeregisterVolumeError {
fn from(err: io::Error) -> DeregisterVolumeError {
DeregisterVolumeError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeregisterVolumeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeregisterVolumeError {
fn description(&self) -> &str {
match *self {
DeregisterVolumeError::ResourceNotFound(ref cause) => cause,
DeregisterVolumeError::Validation(ref cause) => cause,
DeregisterVolumeError::Credentials(ref err) => err.description(),
DeregisterVolumeError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeregisterVolumeError::ParseError(ref cause) => cause,
DeregisterVolumeError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAgentVersionsError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAgentVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAgentVersionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeAgentVersionsError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeAgentVersionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeAgentVersionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeAgentVersionsError {
fn from(err: serde_json::error::Error) -> DescribeAgentVersionsError {
DescribeAgentVersionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeAgentVersionsError {
fn from(err: CredentialsError) -> DescribeAgentVersionsError {
DescribeAgentVersionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAgentVersionsError {
fn from(err: HttpDispatchError) -> DescribeAgentVersionsError {
DescribeAgentVersionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAgentVersionsError {
fn from(err: io::Error) -> DescribeAgentVersionsError {
DescribeAgentVersionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAgentVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAgentVersionsError {
fn description(&self) -> &str {
match *self {
DescribeAgentVersionsError::ResourceNotFound(ref cause) => cause,
DescribeAgentVersionsError::Validation(ref cause) => cause,
DescribeAgentVersionsError::Credentials(ref err) => err.description(),
DescribeAgentVersionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAgentVersionsError::ParseError(ref cause) => cause,
DescribeAgentVersionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAppsError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAppsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAppsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeAppsError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeAppsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeAppsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeAppsError {
fn from(err: serde_json::error::Error) -> DescribeAppsError {
DescribeAppsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeAppsError {
fn from(err: CredentialsError) -> DescribeAppsError {
DescribeAppsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAppsError {
fn from(err: HttpDispatchError) -> DescribeAppsError {
DescribeAppsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAppsError {
fn from(err: io::Error) -> DescribeAppsError {
DescribeAppsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAppsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAppsError {
fn description(&self) -> &str {
match *self {
DescribeAppsError::ResourceNotFound(ref cause) => cause,
DescribeAppsError::Validation(ref cause) => cause,
DescribeAppsError::Credentials(ref err) => err.description(),
DescribeAppsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeAppsError::ParseError(ref cause) => cause,
DescribeAppsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeCommandsError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeCommandsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeCommandsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeCommandsError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeCommandsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeCommandsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeCommandsError {
fn from(err: serde_json::error::Error) -> DescribeCommandsError {
DescribeCommandsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeCommandsError {
fn from(err: CredentialsError) -> DescribeCommandsError {
DescribeCommandsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeCommandsError {
fn from(err: HttpDispatchError) -> DescribeCommandsError {
DescribeCommandsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeCommandsError {
fn from(err: io::Error) -> DescribeCommandsError {
DescribeCommandsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeCommandsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeCommandsError {
fn description(&self) -> &str {
match *self {
DescribeCommandsError::ResourceNotFound(ref cause) => cause,
DescribeCommandsError::Validation(ref cause) => cause,
DescribeCommandsError::Credentials(ref err) => err.description(),
DescribeCommandsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeCommandsError::ParseError(ref cause) => cause,
DescribeCommandsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDeploymentsError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDeploymentsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDeploymentsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeDeploymentsError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeDeploymentsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeDeploymentsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeDeploymentsError {
fn from(err: serde_json::error::Error) -> DescribeDeploymentsError {
DescribeDeploymentsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeDeploymentsError {
fn from(err: CredentialsError) -> DescribeDeploymentsError {
DescribeDeploymentsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDeploymentsError {
fn from(err: HttpDispatchError) -> DescribeDeploymentsError {
DescribeDeploymentsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDeploymentsError {
fn from(err: io::Error) -> DescribeDeploymentsError {
DescribeDeploymentsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDeploymentsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDeploymentsError {
fn description(&self) -> &str {
match *self {
DescribeDeploymentsError::ResourceNotFound(ref cause) => cause,
DescribeDeploymentsError::Validation(ref cause) => cause,
DescribeDeploymentsError::Credentials(ref err) => err.description(),
DescribeDeploymentsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeDeploymentsError::ParseError(ref cause) => cause,
DescribeDeploymentsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeEcsClustersError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeEcsClustersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeEcsClustersError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeEcsClustersError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeEcsClustersError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeEcsClustersError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeEcsClustersError {
fn from(err: serde_json::error::Error) -> DescribeEcsClustersError {
DescribeEcsClustersError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeEcsClustersError {
fn from(err: CredentialsError) -> DescribeEcsClustersError {
DescribeEcsClustersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeEcsClustersError {
fn from(err: HttpDispatchError) -> DescribeEcsClustersError {
DescribeEcsClustersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeEcsClustersError {
fn from(err: io::Error) -> DescribeEcsClustersError {
DescribeEcsClustersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeEcsClustersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeEcsClustersError {
fn description(&self) -> &str {
match *self {
DescribeEcsClustersError::ResourceNotFound(ref cause) => cause,
DescribeEcsClustersError::Validation(ref cause) => cause,
DescribeEcsClustersError::Credentials(ref err) => err.description(),
DescribeEcsClustersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeEcsClustersError::ParseError(ref cause) => cause,
DescribeEcsClustersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeElasticIpsError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeElasticIpsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeElasticIpsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeElasticIpsError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeElasticIpsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeElasticIpsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeElasticIpsError {
fn from(err: serde_json::error::Error) -> DescribeElasticIpsError {
DescribeElasticIpsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeElasticIpsError {
fn from(err: CredentialsError) -> DescribeElasticIpsError {
DescribeElasticIpsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeElasticIpsError {
fn from(err: HttpDispatchError) -> DescribeElasticIpsError {
DescribeElasticIpsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeElasticIpsError {
fn from(err: io::Error) -> DescribeElasticIpsError {
DescribeElasticIpsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeElasticIpsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeElasticIpsError {
fn description(&self) -> &str {
match *self {
DescribeElasticIpsError::ResourceNotFound(ref cause) => cause,
DescribeElasticIpsError::Validation(ref cause) => cause,
DescribeElasticIpsError::Credentials(ref err) => err.description(),
DescribeElasticIpsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeElasticIpsError::ParseError(ref cause) => cause,
DescribeElasticIpsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeElasticLoadBalancersError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeElasticLoadBalancersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeElasticLoadBalancersError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeElasticLoadBalancersError::ResourceNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return DescribeElasticLoadBalancersError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeElasticLoadBalancersError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeElasticLoadBalancersError {
fn from(err: serde_json::error::Error) -> DescribeElasticLoadBalancersError {
DescribeElasticLoadBalancersError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeElasticLoadBalancersError {
fn from(err: CredentialsError) -> DescribeElasticLoadBalancersError {
DescribeElasticLoadBalancersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeElasticLoadBalancersError {
fn from(err: HttpDispatchError) -> DescribeElasticLoadBalancersError {
DescribeElasticLoadBalancersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeElasticLoadBalancersError {
fn from(err: io::Error) -> DescribeElasticLoadBalancersError {
DescribeElasticLoadBalancersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeElasticLoadBalancersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeElasticLoadBalancersError {
fn description(&self) -> &str {
match *self {
DescribeElasticLoadBalancersError::ResourceNotFound(ref cause) => cause,
DescribeElasticLoadBalancersError::Validation(ref cause) => cause,
DescribeElasticLoadBalancersError::Credentials(ref err) => err.description(),
DescribeElasticLoadBalancersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeElasticLoadBalancersError::ParseError(ref cause) => cause,
DescribeElasticLoadBalancersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeInstancesError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeInstancesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeInstancesError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeInstancesError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeInstancesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeInstancesError {
fn from(err: serde_json::error::Error) -> DescribeInstancesError {
DescribeInstancesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeInstancesError {
fn from(err: CredentialsError) -> DescribeInstancesError {
DescribeInstancesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeInstancesError {
fn from(err: HttpDispatchError) -> DescribeInstancesError {
DescribeInstancesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeInstancesError {
fn from(err: io::Error) -> DescribeInstancesError {
DescribeInstancesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeInstancesError {
fn description(&self) -> &str {
match *self {
DescribeInstancesError::ResourceNotFound(ref cause) => cause,
DescribeInstancesError::Validation(ref cause) => cause,
DescribeInstancesError::Credentials(ref err) => err.description(),
DescribeInstancesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeInstancesError::ParseError(ref cause) => cause,
DescribeInstancesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeLayersError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeLayersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeLayersError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeLayersError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeLayersError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeLayersError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeLayersError {
fn from(err: serde_json::error::Error) -> DescribeLayersError {
DescribeLayersError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeLayersError {
fn from(err: CredentialsError) -> DescribeLayersError {
DescribeLayersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeLayersError {
fn from(err: HttpDispatchError) -> DescribeLayersError {
DescribeLayersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeLayersError {
fn from(err: io::Error) -> DescribeLayersError {
DescribeLayersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeLayersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeLayersError {
fn description(&self) -> &str {
match *self {
DescribeLayersError::ResourceNotFound(ref cause) => cause,
DescribeLayersError::Validation(ref cause) => cause,
DescribeLayersError::Credentials(ref err) => err.description(),
DescribeLayersError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeLayersError::ParseError(ref cause) => cause,
DescribeLayersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeLoadBasedAutoScalingError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeLoadBasedAutoScalingError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeLoadBasedAutoScalingError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeLoadBasedAutoScalingError::ResourceNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return DescribeLoadBasedAutoScalingError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeLoadBasedAutoScalingError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeLoadBasedAutoScalingError {
fn from(err: serde_json::error::Error) -> DescribeLoadBasedAutoScalingError {
DescribeLoadBasedAutoScalingError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeLoadBasedAutoScalingError {
fn from(err: CredentialsError) -> DescribeLoadBasedAutoScalingError {
DescribeLoadBasedAutoScalingError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeLoadBasedAutoScalingError {
fn from(err: HttpDispatchError) -> DescribeLoadBasedAutoScalingError {
DescribeLoadBasedAutoScalingError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeLoadBasedAutoScalingError {
fn from(err: io::Error) -> DescribeLoadBasedAutoScalingError {
DescribeLoadBasedAutoScalingError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeLoadBasedAutoScalingError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeLoadBasedAutoScalingError {
fn description(&self) -> &str {
match *self {
DescribeLoadBasedAutoScalingError::ResourceNotFound(ref cause) => cause,
DescribeLoadBasedAutoScalingError::Validation(ref cause) => cause,
DescribeLoadBasedAutoScalingError::Credentials(ref err) => err.description(),
DescribeLoadBasedAutoScalingError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeLoadBasedAutoScalingError::ParseError(ref cause) => cause,
DescribeLoadBasedAutoScalingError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeMyUserProfileError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeMyUserProfileError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeMyUserProfileError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ValidationException" => {
return DescribeMyUserProfileError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeMyUserProfileError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeMyUserProfileError {
fn from(err: serde_json::error::Error) -> DescribeMyUserProfileError {
DescribeMyUserProfileError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeMyUserProfileError {
fn from(err: CredentialsError) -> DescribeMyUserProfileError {
DescribeMyUserProfileError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeMyUserProfileError {
fn from(err: HttpDispatchError) -> DescribeMyUserProfileError {
DescribeMyUserProfileError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeMyUserProfileError {
fn from(err: io::Error) -> DescribeMyUserProfileError {
DescribeMyUserProfileError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeMyUserProfileError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeMyUserProfileError {
fn description(&self) -> &str {
match *self {
DescribeMyUserProfileError::Validation(ref cause) => cause,
DescribeMyUserProfileError::Credentials(ref err) => err.description(),
DescribeMyUserProfileError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeMyUserProfileError::ParseError(ref cause) => cause,
DescribeMyUserProfileError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeOperatingSystemsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeOperatingSystemsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeOperatingSystemsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ValidationException" => {
return DescribeOperatingSystemsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeOperatingSystemsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeOperatingSystemsError {
fn from(err: serde_json::error::Error) -> DescribeOperatingSystemsError {
DescribeOperatingSystemsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeOperatingSystemsError {
fn from(err: CredentialsError) -> DescribeOperatingSystemsError {
DescribeOperatingSystemsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeOperatingSystemsError {
fn from(err: HttpDispatchError) -> DescribeOperatingSystemsError {
DescribeOperatingSystemsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeOperatingSystemsError {
fn from(err: io::Error) -> DescribeOperatingSystemsError {
DescribeOperatingSystemsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeOperatingSystemsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeOperatingSystemsError {
fn description(&self) -> &str {
match *self {
DescribeOperatingSystemsError::Validation(ref cause) => cause,
DescribeOperatingSystemsError::Credentials(ref err) => err.description(),
DescribeOperatingSystemsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeOperatingSystemsError::ParseError(ref cause) => cause,
DescribeOperatingSystemsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribePermissionsError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribePermissionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribePermissionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribePermissionsError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribePermissionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribePermissionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribePermissionsError {
fn from(err: serde_json::error::Error) -> DescribePermissionsError {
DescribePermissionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribePermissionsError {
fn from(err: CredentialsError) -> DescribePermissionsError {
DescribePermissionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribePermissionsError {
fn from(err: HttpDispatchError) -> DescribePermissionsError {
DescribePermissionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribePermissionsError {
fn from(err: io::Error) -> DescribePermissionsError {
DescribePermissionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribePermissionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribePermissionsError {
fn description(&self) -> &str {
match *self {
DescribePermissionsError::ResourceNotFound(ref cause) => cause,
DescribePermissionsError::Validation(ref cause) => cause,
DescribePermissionsError::Credentials(ref err) => err.description(),
DescribePermissionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribePermissionsError::ParseError(ref cause) => cause,
DescribePermissionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeRaidArraysError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeRaidArraysError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeRaidArraysError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeRaidArraysError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeRaidArraysError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeRaidArraysError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeRaidArraysError {
fn from(err: serde_json::error::Error) -> DescribeRaidArraysError {
DescribeRaidArraysError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeRaidArraysError {
fn from(err: CredentialsError) -> DescribeRaidArraysError {
DescribeRaidArraysError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeRaidArraysError {
fn from(err: HttpDispatchError) -> DescribeRaidArraysError {
DescribeRaidArraysError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeRaidArraysError {
fn from(err: io::Error) -> DescribeRaidArraysError {
DescribeRaidArraysError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeRaidArraysError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeRaidArraysError {
fn description(&self) -> &str {
match *self {
DescribeRaidArraysError::ResourceNotFound(ref cause) => cause,
DescribeRaidArraysError::Validation(ref cause) => cause,
DescribeRaidArraysError::Credentials(ref err) => err.description(),
DescribeRaidArraysError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeRaidArraysError::ParseError(ref cause) => cause,
DescribeRaidArraysError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeRdsDbInstancesError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeRdsDbInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeRdsDbInstancesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeRdsDbInstancesError::ResourceNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return DescribeRdsDbInstancesError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeRdsDbInstancesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeRdsDbInstancesError {
fn from(err: serde_json::error::Error) -> DescribeRdsDbInstancesError {
DescribeRdsDbInstancesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeRdsDbInstancesError {
fn from(err: CredentialsError) -> DescribeRdsDbInstancesError {
DescribeRdsDbInstancesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeRdsDbInstancesError {
fn from(err: HttpDispatchError) -> DescribeRdsDbInstancesError {
DescribeRdsDbInstancesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeRdsDbInstancesError {
fn from(err: io::Error) -> DescribeRdsDbInstancesError {
DescribeRdsDbInstancesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeRdsDbInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeRdsDbInstancesError {
fn description(&self) -> &str {
match *self {
DescribeRdsDbInstancesError::ResourceNotFound(ref cause) => cause,
DescribeRdsDbInstancesError::Validation(ref cause) => cause,
DescribeRdsDbInstancesError::Credentials(ref err) => err.description(),
DescribeRdsDbInstancesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeRdsDbInstancesError::ParseError(ref cause) => cause,
DescribeRdsDbInstancesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeServiceErrorsError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeServiceErrorsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeServiceErrorsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeServiceErrorsError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeServiceErrorsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeServiceErrorsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeServiceErrorsError {
fn from(err: serde_json::error::Error) -> DescribeServiceErrorsError {
DescribeServiceErrorsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeServiceErrorsError {
fn from(err: CredentialsError) -> DescribeServiceErrorsError {
DescribeServiceErrorsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeServiceErrorsError {
fn from(err: HttpDispatchError) -> DescribeServiceErrorsError {
DescribeServiceErrorsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeServiceErrorsError {
fn from(err: io::Error) -> DescribeServiceErrorsError {
DescribeServiceErrorsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeServiceErrorsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeServiceErrorsError {
fn description(&self) -> &str {
match *self {
DescribeServiceErrorsError::ResourceNotFound(ref cause) => cause,
DescribeServiceErrorsError::Validation(ref cause) => cause,
DescribeServiceErrorsError::Credentials(ref err) => err.description(),
DescribeServiceErrorsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeServiceErrorsError::ParseError(ref cause) => cause,
DescribeServiceErrorsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeStackProvisioningParametersError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeStackProvisioningParametersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeStackProvisioningParametersError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeStackProvisioningParametersError::ResourceNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return DescribeStackProvisioningParametersError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return DescribeStackProvisioningParametersError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeStackProvisioningParametersError {
fn from(err: serde_json::error::Error) -> DescribeStackProvisioningParametersError {
DescribeStackProvisioningParametersError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeStackProvisioningParametersError {
fn from(err: CredentialsError) -> DescribeStackProvisioningParametersError {
DescribeStackProvisioningParametersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeStackProvisioningParametersError {
fn from(err: HttpDispatchError) -> DescribeStackProvisioningParametersError {
DescribeStackProvisioningParametersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeStackProvisioningParametersError {
fn from(err: io::Error) -> DescribeStackProvisioningParametersError {
DescribeStackProvisioningParametersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeStackProvisioningParametersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeStackProvisioningParametersError {
fn description(&self) -> &str {
match *self {
DescribeStackProvisioningParametersError::ResourceNotFound(ref cause) => cause,
DescribeStackProvisioningParametersError::Validation(ref cause) => cause,
DescribeStackProvisioningParametersError::Credentials(ref err) => err.description(),
DescribeStackProvisioningParametersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeStackProvisioningParametersError::ParseError(ref cause) => cause,
DescribeStackProvisioningParametersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeStackSummaryError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeStackSummaryError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeStackSummaryError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeStackSummaryError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeStackSummaryError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeStackSummaryError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeStackSummaryError {
fn from(err: serde_json::error::Error) -> DescribeStackSummaryError {
DescribeStackSummaryError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeStackSummaryError {
fn from(err: CredentialsError) -> DescribeStackSummaryError {
DescribeStackSummaryError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeStackSummaryError {
fn from(err: HttpDispatchError) -> DescribeStackSummaryError {
DescribeStackSummaryError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeStackSummaryError {
fn from(err: io::Error) -> DescribeStackSummaryError {
DescribeStackSummaryError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeStackSummaryError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeStackSummaryError {
fn description(&self) -> &str {
match *self {
DescribeStackSummaryError::ResourceNotFound(ref cause) => cause,
DescribeStackSummaryError::Validation(ref cause) => cause,
DescribeStackSummaryError::Credentials(ref err) => err.description(),
DescribeStackSummaryError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeStackSummaryError::ParseError(ref cause) => cause,
DescribeStackSummaryError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeStacksError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeStacksError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeStacksError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeStacksError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeStacksError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeStacksError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeStacksError {
fn from(err: serde_json::error::Error) -> DescribeStacksError {
DescribeStacksError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeStacksError {
fn from(err: CredentialsError) -> DescribeStacksError {
DescribeStacksError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeStacksError {
fn from(err: HttpDispatchError) -> DescribeStacksError {
DescribeStacksError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeStacksError {
fn from(err: io::Error) -> DescribeStacksError {
DescribeStacksError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeStacksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeStacksError {
fn description(&self) -> &str {
match *self {
DescribeStacksError::ResourceNotFound(ref cause) => cause,
DescribeStacksError::Validation(ref cause) => cause,
DescribeStacksError::Credentials(ref err) => err.description(),
DescribeStacksError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeStacksError::ParseError(ref cause) => cause,
DescribeStacksError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeTimeBasedAutoScalingError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeTimeBasedAutoScalingError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeTimeBasedAutoScalingError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeTimeBasedAutoScalingError::ResourceNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return DescribeTimeBasedAutoScalingError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeTimeBasedAutoScalingError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeTimeBasedAutoScalingError {
fn from(err: serde_json::error::Error) -> DescribeTimeBasedAutoScalingError {
DescribeTimeBasedAutoScalingError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeTimeBasedAutoScalingError {
fn from(err: CredentialsError) -> DescribeTimeBasedAutoScalingError {
DescribeTimeBasedAutoScalingError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeTimeBasedAutoScalingError {
fn from(err: HttpDispatchError) -> DescribeTimeBasedAutoScalingError {
DescribeTimeBasedAutoScalingError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeTimeBasedAutoScalingError {
fn from(err: io::Error) -> DescribeTimeBasedAutoScalingError {
DescribeTimeBasedAutoScalingError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeTimeBasedAutoScalingError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeTimeBasedAutoScalingError {
fn description(&self) -> &str {
match *self {
DescribeTimeBasedAutoScalingError::ResourceNotFound(ref cause) => cause,
DescribeTimeBasedAutoScalingError::Validation(ref cause) => cause,
DescribeTimeBasedAutoScalingError::Credentials(ref err) => err.description(),
DescribeTimeBasedAutoScalingError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeTimeBasedAutoScalingError::ParseError(ref cause) => cause,
DescribeTimeBasedAutoScalingError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeUserProfilesError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeUserProfilesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeUserProfilesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeUserProfilesError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeUserProfilesError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeUserProfilesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeUserProfilesError {
fn from(err: serde_json::error::Error) -> DescribeUserProfilesError {
DescribeUserProfilesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeUserProfilesError {
fn from(err: CredentialsError) -> DescribeUserProfilesError {
DescribeUserProfilesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeUserProfilesError {
fn from(err: HttpDispatchError) -> DescribeUserProfilesError {
DescribeUserProfilesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeUserProfilesError {
fn from(err: io::Error) -> DescribeUserProfilesError {
DescribeUserProfilesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeUserProfilesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeUserProfilesError {
fn description(&self) -> &str {
match *self {
DescribeUserProfilesError::ResourceNotFound(ref cause) => cause,
DescribeUserProfilesError::Validation(ref cause) => cause,
DescribeUserProfilesError::Credentials(ref err) => err.description(),
DescribeUserProfilesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeUserProfilesError::ParseError(ref cause) => cause,
DescribeUserProfilesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeVolumesError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeVolumesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeVolumesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeVolumesError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeVolumesError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeVolumesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeVolumesError {
fn from(err: serde_json::error::Error) -> DescribeVolumesError {
DescribeVolumesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeVolumesError {
fn from(err: CredentialsError) -> DescribeVolumesError {
DescribeVolumesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeVolumesError {
fn from(err: HttpDispatchError) -> DescribeVolumesError {
DescribeVolumesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeVolumesError {
fn from(err: io::Error) -> DescribeVolumesError {
DescribeVolumesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeVolumesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeVolumesError {
fn description(&self) -> &str {
match *self {
DescribeVolumesError::ResourceNotFound(ref cause) => cause,
DescribeVolumesError::Validation(ref cause) => cause,
DescribeVolumesError::Credentials(ref err) => err.description(),
DescribeVolumesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeVolumesError::ParseError(ref cause) => cause,
DescribeVolumesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DetachElasticLoadBalancerError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DetachElasticLoadBalancerError {
pub fn from_response(res: BufferedHttpResponse) -> DetachElasticLoadBalancerError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DetachElasticLoadBalancerError::ResourceNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return DetachElasticLoadBalancerError::Validation(error_message.to_string());
}
_ => {}
}
}
return DetachElasticLoadBalancerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DetachElasticLoadBalancerError {
fn from(err: serde_json::error::Error) -> DetachElasticLoadBalancerError {
DetachElasticLoadBalancerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DetachElasticLoadBalancerError {
fn from(err: CredentialsError) -> DetachElasticLoadBalancerError {
DetachElasticLoadBalancerError::Credentials(err)
}
}
impl From<HttpDispatchError> for DetachElasticLoadBalancerError {
fn from(err: HttpDispatchError) -> DetachElasticLoadBalancerError {
DetachElasticLoadBalancerError::HttpDispatch(err)
}
}
impl From<io::Error> for DetachElasticLoadBalancerError {
fn from(err: io::Error) -> DetachElasticLoadBalancerError {
DetachElasticLoadBalancerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DetachElasticLoadBalancerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DetachElasticLoadBalancerError {
fn description(&self) -> &str {
match *self {
DetachElasticLoadBalancerError::ResourceNotFound(ref cause) => cause,
DetachElasticLoadBalancerError::Validation(ref cause) => cause,
DetachElasticLoadBalancerError::Credentials(ref err) => err.description(),
DetachElasticLoadBalancerError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DetachElasticLoadBalancerError::ParseError(ref cause) => cause,
DetachElasticLoadBalancerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateElasticIpError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisassociateElasticIpError {
pub fn from_response(res: BufferedHttpResponse) -> DisassociateElasticIpError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DisassociateElasticIpError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DisassociateElasticIpError::Validation(error_message.to_string());
}
_ => {}
}
}
return DisassociateElasticIpError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DisassociateElasticIpError {
fn from(err: serde_json::error::Error) -> DisassociateElasticIpError {
DisassociateElasticIpError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DisassociateElasticIpError {
fn from(err: CredentialsError) -> DisassociateElasticIpError {
DisassociateElasticIpError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisassociateElasticIpError {
fn from(err: HttpDispatchError) -> DisassociateElasticIpError {
DisassociateElasticIpError::HttpDispatch(err)
}
}
impl From<io::Error> for DisassociateElasticIpError {
fn from(err: io::Error) -> DisassociateElasticIpError {
DisassociateElasticIpError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisassociateElasticIpError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateElasticIpError {
fn description(&self) -> &str {
match *self {
DisassociateElasticIpError::ResourceNotFound(ref cause) => cause,
DisassociateElasticIpError::Validation(ref cause) => cause,
DisassociateElasticIpError::Credentials(ref err) => err.description(),
DisassociateElasticIpError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DisassociateElasticIpError::ParseError(ref cause) => cause,
DisassociateElasticIpError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetHostnameSuggestionError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetHostnameSuggestionError {
pub fn from_response(res: BufferedHttpResponse) -> GetHostnameSuggestionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return GetHostnameSuggestionError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return GetHostnameSuggestionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetHostnameSuggestionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetHostnameSuggestionError {
fn from(err: serde_json::error::Error) -> GetHostnameSuggestionError {
GetHostnameSuggestionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetHostnameSuggestionError {
fn from(err: CredentialsError) -> GetHostnameSuggestionError {
GetHostnameSuggestionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetHostnameSuggestionError {
fn from(err: HttpDispatchError) -> GetHostnameSuggestionError {
GetHostnameSuggestionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetHostnameSuggestionError {
fn from(err: io::Error) -> GetHostnameSuggestionError {
GetHostnameSuggestionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetHostnameSuggestionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetHostnameSuggestionError {
fn description(&self) -> &str {
match *self {
GetHostnameSuggestionError::ResourceNotFound(ref cause) => cause,
GetHostnameSuggestionError::Validation(ref cause) => cause,
GetHostnameSuggestionError::Credentials(ref err) => err.description(),
GetHostnameSuggestionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetHostnameSuggestionError::ParseError(ref cause) => cause,
GetHostnameSuggestionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GrantAccessError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GrantAccessError {
pub fn from_response(res: BufferedHttpResponse) -> GrantAccessError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return GrantAccessError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return GrantAccessError::Validation(error_message.to_string());
}
_ => {}
}
}
return GrantAccessError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GrantAccessError {
fn from(err: serde_json::error::Error) -> GrantAccessError {
GrantAccessError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GrantAccessError {
fn from(err: CredentialsError) -> GrantAccessError {
GrantAccessError::Credentials(err)
}
}
impl From<HttpDispatchError> for GrantAccessError {
fn from(err: HttpDispatchError) -> GrantAccessError {
GrantAccessError::HttpDispatch(err)
}
}
impl From<io::Error> for GrantAccessError {
fn from(err: io::Error) -> GrantAccessError {
GrantAccessError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GrantAccessError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GrantAccessError {
fn description(&self) -> &str {
match *self {
GrantAccessError::ResourceNotFound(ref cause) => cause,
GrantAccessError::Validation(ref cause) => cause,
GrantAccessError::Credentials(ref err) => err.description(),
GrantAccessError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GrantAccessError::ParseError(ref cause) => cause,
GrantAccessError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTagsError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTagsError {
pub fn from_response(res: BufferedHttpResponse) -> ListTagsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return ListTagsError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return ListTagsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListTagsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListTagsError {
fn from(err: serde_json::error::Error) -> ListTagsError {
ListTagsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListTagsError {
fn from(err: CredentialsError) -> ListTagsError {
ListTagsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTagsError {
fn from(err: HttpDispatchError) -> ListTagsError {
ListTagsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTagsError {
fn from(err: io::Error) -> ListTagsError {
ListTagsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTagsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTagsError {
fn description(&self) -> &str {
match *self {
ListTagsError::ResourceNotFound(ref cause) => cause,
ListTagsError::Validation(ref cause) => cause,
ListTagsError::Credentials(ref err) => err.description(),
ListTagsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListTagsError::ParseError(ref cause) => cause,
ListTagsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RebootInstanceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RebootInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RebootInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return RebootInstanceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return RebootInstanceError::Validation(error_message.to_string());
}
_ => {}
}
}
return RebootInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RebootInstanceError {
fn from(err: serde_json::error::Error) -> RebootInstanceError {
RebootInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RebootInstanceError {
fn from(err: CredentialsError) -> RebootInstanceError {
RebootInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for RebootInstanceError {
fn from(err: HttpDispatchError) -> RebootInstanceError {
RebootInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for RebootInstanceError {
fn from(err: io::Error) -> RebootInstanceError {
RebootInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RebootInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RebootInstanceError {
fn description(&self) -> &str {
match *self {
RebootInstanceError::ResourceNotFound(ref cause) => cause,
RebootInstanceError::Validation(ref cause) => cause,
RebootInstanceError::Credentials(ref err) => err.description(),
RebootInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
RebootInstanceError::ParseError(ref cause) => cause,
RebootInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RegisterEcsClusterError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RegisterEcsClusterError {
pub fn from_response(res: BufferedHttpResponse) -> RegisterEcsClusterError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return RegisterEcsClusterError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return RegisterEcsClusterError::Validation(error_message.to_string());
}
_ => {}
}
}
return RegisterEcsClusterError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RegisterEcsClusterError {
fn from(err: serde_json::error::Error) -> RegisterEcsClusterError {
RegisterEcsClusterError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RegisterEcsClusterError {
fn from(err: CredentialsError) -> RegisterEcsClusterError {
RegisterEcsClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for RegisterEcsClusterError {
fn from(err: HttpDispatchError) -> RegisterEcsClusterError {
RegisterEcsClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for RegisterEcsClusterError {
fn from(err: io::Error) -> RegisterEcsClusterError {
RegisterEcsClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RegisterEcsClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RegisterEcsClusterError {
fn description(&self) -> &str {
match *self {
RegisterEcsClusterError::ResourceNotFound(ref cause) => cause,
RegisterEcsClusterError::Validation(ref cause) => cause,
RegisterEcsClusterError::Credentials(ref err) => err.description(),
RegisterEcsClusterError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RegisterEcsClusterError::ParseError(ref cause) => cause,
RegisterEcsClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RegisterElasticIpError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RegisterElasticIpError {
pub fn from_response(res: BufferedHttpResponse) -> RegisterElasticIpError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return RegisterElasticIpError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return RegisterElasticIpError::Validation(error_message.to_string());
}
_ => {}
}
}
return RegisterElasticIpError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RegisterElasticIpError {
fn from(err: serde_json::error::Error) -> RegisterElasticIpError {
RegisterElasticIpError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RegisterElasticIpError {
fn from(err: CredentialsError) -> RegisterElasticIpError {
RegisterElasticIpError::Credentials(err)
}
}
impl From<HttpDispatchError> for RegisterElasticIpError {
fn from(err: HttpDispatchError) -> RegisterElasticIpError {
RegisterElasticIpError::HttpDispatch(err)
}
}
impl From<io::Error> for RegisterElasticIpError {
fn from(err: io::Error) -> RegisterElasticIpError {
RegisterElasticIpError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RegisterElasticIpError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RegisterElasticIpError {
fn description(&self) -> &str {
match *self {
RegisterElasticIpError::ResourceNotFound(ref cause) => cause,
RegisterElasticIpError::Validation(ref cause) => cause,
RegisterElasticIpError::Credentials(ref err) => err.description(),
RegisterElasticIpError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RegisterElasticIpError::ParseError(ref cause) => cause,
RegisterElasticIpError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RegisterInstanceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RegisterInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RegisterInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return RegisterInstanceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return RegisterInstanceError::Validation(error_message.to_string());
}
_ => {}
}
}
return RegisterInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RegisterInstanceError {
fn from(err: serde_json::error::Error) -> RegisterInstanceError {
RegisterInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RegisterInstanceError {
fn from(err: CredentialsError) -> RegisterInstanceError {
RegisterInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for RegisterInstanceError {
fn from(err: HttpDispatchError) -> RegisterInstanceError {
RegisterInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for RegisterInstanceError {
fn from(err: io::Error) -> RegisterInstanceError {
RegisterInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RegisterInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RegisterInstanceError {
fn description(&self) -> &str {
match *self {
RegisterInstanceError::ResourceNotFound(ref cause) => cause,
RegisterInstanceError::Validation(ref cause) => cause,
RegisterInstanceError::Credentials(ref err) => err.description(),
RegisterInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
RegisterInstanceError::ParseError(ref cause) => cause,
RegisterInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RegisterRdsDbInstanceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RegisterRdsDbInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RegisterRdsDbInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return RegisterRdsDbInstanceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return RegisterRdsDbInstanceError::Validation(error_message.to_string());
}
_ => {}
}
}
return RegisterRdsDbInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RegisterRdsDbInstanceError {
fn from(err: serde_json::error::Error) -> RegisterRdsDbInstanceError {
RegisterRdsDbInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RegisterRdsDbInstanceError {
fn from(err: CredentialsError) -> RegisterRdsDbInstanceError {
RegisterRdsDbInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for RegisterRdsDbInstanceError {
fn from(err: HttpDispatchError) -> RegisterRdsDbInstanceError {
RegisterRdsDbInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for RegisterRdsDbInstanceError {
fn from(err: io::Error) -> RegisterRdsDbInstanceError {
RegisterRdsDbInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RegisterRdsDbInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RegisterRdsDbInstanceError {
fn description(&self) -> &str {
match *self {
RegisterRdsDbInstanceError::ResourceNotFound(ref cause) => cause,
RegisterRdsDbInstanceError::Validation(ref cause) => cause,
RegisterRdsDbInstanceError::Credentials(ref err) => err.description(),
RegisterRdsDbInstanceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RegisterRdsDbInstanceError::ParseError(ref cause) => cause,
RegisterRdsDbInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RegisterVolumeError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RegisterVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> RegisterVolumeError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return RegisterVolumeError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return RegisterVolumeError::Validation(error_message.to_string());
}
_ => {}
}
}
return RegisterVolumeError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RegisterVolumeError {
fn from(err: serde_json::error::Error) -> RegisterVolumeError {
RegisterVolumeError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RegisterVolumeError {
fn from(err: CredentialsError) -> RegisterVolumeError {
RegisterVolumeError::Credentials(err)
}
}
impl From<HttpDispatchError> for RegisterVolumeError {
fn from(err: HttpDispatchError) -> RegisterVolumeError {
RegisterVolumeError::HttpDispatch(err)
}
}
impl From<io::Error> for RegisterVolumeError {
fn from(err: io::Error) -> RegisterVolumeError {
RegisterVolumeError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RegisterVolumeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RegisterVolumeError {
fn description(&self) -> &str {
match *self {
RegisterVolumeError::ResourceNotFound(ref cause) => cause,
RegisterVolumeError::Validation(ref cause) => cause,
RegisterVolumeError::Credentials(ref err) => err.description(),
RegisterVolumeError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
RegisterVolumeError::ParseError(ref cause) => cause,
RegisterVolumeError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum SetLoadBasedAutoScalingError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl SetLoadBasedAutoScalingError {
pub fn from_response(res: BufferedHttpResponse) -> SetLoadBasedAutoScalingError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return SetLoadBasedAutoScalingError::ResourceNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return SetLoadBasedAutoScalingError::Validation(error_message.to_string());
}
_ => {}
}
}
return SetLoadBasedAutoScalingError::Unknown(res);
}
}
impl From<serde_json::error::Error> for SetLoadBasedAutoScalingError {
fn from(err: serde_json::error::Error) -> SetLoadBasedAutoScalingError {
SetLoadBasedAutoScalingError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for SetLoadBasedAutoScalingError {
fn from(err: CredentialsError) -> SetLoadBasedAutoScalingError {
SetLoadBasedAutoScalingError::Credentials(err)
}
}
impl From<HttpDispatchError> for SetLoadBasedAutoScalingError {
fn from(err: HttpDispatchError) -> SetLoadBasedAutoScalingError {
SetLoadBasedAutoScalingError::HttpDispatch(err)
}
}
impl From<io::Error> for SetLoadBasedAutoScalingError {
fn from(err: io::Error) -> SetLoadBasedAutoScalingError {
SetLoadBasedAutoScalingError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for SetLoadBasedAutoScalingError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for SetLoadBasedAutoScalingError {
fn description(&self) -> &str {
match *self {
SetLoadBasedAutoScalingError::ResourceNotFound(ref cause) => cause,
SetLoadBasedAutoScalingError::Validation(ref cause) => cause,
SetLoadBasedAutoScalingError::Credentials(ref err) => err.description(),
SetLoadBasedAutoScalingError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
SetLoadBasedAutoScalingError::ParseError(ref cause) => cause,
SetLoadBasedAutoScalingError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum SetPermissionError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl SetPermissionError {
pub fn from_response(res: BufferedHttpResponse) -> SetPermissionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return SetPermissionError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return SetPermissionError::Validation(error_message.to_string());
}
_ => {}
}
}
return SetPermissionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for SetPermissionError {
fn from(err: serde_json::error::Error) -> SetPermissionError {
SetPermissionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for SetPermissionError {
fn from(err: CredentialsError) -> SetPermissionError {
SetPermissionError::Credentials(err)
}
}
impl From<HttpDispatchError> for SetPermissionError {
fn from(err: HttpDispatchError) -> SetPermissionError {
SetPermissionError::HttpDispatch(err)
}
}
impl From<io::Error> for SetPermissionError {
fn from(err: io::Error) -> SetPermissionError {
SetPermissionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for SetPermissionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for SetPermissionError {
fn description(&self) -> &str {
match *self {
SetPermissionError::ResourceNotFound(ref cause) => cause,
SetPermissionError::Validation(ref cause) => cause,
SetPermissionError::Credentials(ref err) => err.description(),
SetPermissionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
SetPermissionError::ParseError(ref cause) => cause,
SetPermissionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum SetTimeBasedAutoScalingError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl SetTimeBasedAutoScalingError {
pub fn from_response(res: BufferedHttpResponse) -> SetTimeBasedAutoScalingError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return SetTimeBasedAutoScalingError::ResourceNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return SetTimeBasedAutoScalingError::Validation(error_message.to_string());
}
_ => {}
}
}
return SetTimeBasedAutoScalingError::Unknown(res);
}
}
impl From<serde_json::error::Error> for SetTimeBasedAutoScalingError {
fn from(err: serde_json::error::Error) -> SetTimeBasedAutoScalingError {
SetTimeBasedAutoScalingError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for SetTimeBasedAutoScalingError {
fn from(err: CredentialsError) -> SetTimeBasedAutoScalingError {
SetTimeBasedAutoScalingError::Credentials(err)
}
}
impl From<HttpDispatchError> for SetTimeBasedAutoScalingError {
fn from(err: HttpDispatchError) -> SetTimeBasedAutoScalingError {
SetTimeBasedAutoScalingError::HttpDispatch(err)
}
}
impl From<io::Error> for SetTimeBasedAutoScalingError {
fn from(err: io::Error) -> SetTimeBasedAutoScalingError {
SetTimeBasedAutoScalingError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for SetTimeBasedAutoScalingError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for SetTimeBasedAutoScalingError {
fn description(&self) -> &str {
match *self {
SetTimeBasedAutoScalingError::ResourceNotFound(ref cause) => cause,
SetTimeBasedAutoScalingError::Validation(ref cause) => cause,
SetTimeBasedAutoScalingError::Credentials(ref err) => err.description(),
SetTimeBasedAutoScalingError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
SetTimeBasedAutoScalingError::ParseError(ref cause) => cause,
SetTimeBasedAutoScalingError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartInstanceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> StartInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return StartInstanceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return StartInstanceError::Validation(error_message.to_string());
}
_ => {}
}
}
return StartInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartInstanceError {
fn from(err: serde_json::error::Error) -> StartInstanceError {
StartInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartInstanceError {
fn from(err: CredentialsError) -> StartInstanceError {
StartInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartInstanceError {
fn from(err: HttpDispatchError) -> StartInstanceError {
StartInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for StartInstanceError {
fn from(err: io::Error) -> StartInstanceError {
StartInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartInstanceError {
fn description(&self) -> &str {
match *self {
StartInstanceError::ResourceNotFound(ref cause) => cause,
StartInstanceError::Validation(ref cause) => cause,
StartInstanceError::Credentials(ref err) => err.description(),
StartInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StartInstanceError::ParseError(ref cause) => cause,
StartInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartStackError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartStackError {
pub fn from_response(res: BufferedHttpResponse) -> StartStackError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return StartStackError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return StartStackError::Validation(error_message.to_string());
}
_ => {}
}
}
return StartStackError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartStackError {
fn from(err: serde_json::error::Error) -> StartStackError {
StartStackError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartStackError {
fn from(err: CredentialsError) -> StartStackError {
StartStackError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartStackError {
fn from(err: HttpDispatchError) -> StartStackError {
StartStackError::HttpDispatch(err)
}
}
impl From<io::Error> for StartStackError {
fn from(err: io::Error) -> StartStackError {
StartStackError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartStackError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartStackError {
fn description(&self) -> &str {
match *self {
StartStackError::ResourceNotFound(ref cause) => cause,
StartStackError::Validation(ref cause) => cause,
StartStackError::Credentials(ref err) => err.description(),
StartStackError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StartStackError::ParseError(ref cause) => cause,
StartStackError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StopInstanceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StopInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> StopInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return StopInstanceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return StopInstanceError::Validation(error_message.to_string());
}
_ => {}
}
}
return StopInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StopInstanceError {
fn from(err: serde_json::error::Error) -> StopInstanceError {
StopInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StopInstanceError {
fn from(err: CredentialsError) -> StopInstanceError {
StopInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for StopInstanceError {
fn from(err: HttpDispatchError) -> StopInstanceError {
StopInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for StopInstanceError {
fn from(err: io::Error) -> StopInstanceError {
StopInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StopInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StopInstanceError {
fn description(&self) -> &str {
match *self {
StopInstanceError::ResourceNotFound(ref cause) => cause,
StopInstanceError::Validation(ref cause) => cause,
StopInstanceError::Credentials(ref err) => err.description(),
StopInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StopInstanceError::ParseError(ref cause) => cause,
StopInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StopStackError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StopStackError {
pub fn from_response(res: BufferedHttpResponse) -> StopStackError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return StopStackError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return StopStackError::Validation(error_message.to_string());
}
_ => {}
}
}
return StopStackError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StopStackError {
fn from(err: serde_json::error::Error) -> StopStackError {
StopStackError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StopStackError {
fn from(err: CredentialsError) -> StopStackError {
StopStackError::Credentials(err)
}
}
impl From<HttpDispatchError> for StopStackError {
fn from(err: HttpDispatchError) -> StopStackError {
StopStackError::HttpDispatch(err)
}
}
impl From<io::Error> for StopStackError {
fn from(err: io::Error) -> StopStackError {
StopStackError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StopStackError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StopStackError {
fn description(&self) -> &str {
match *self {
StopStackError::ResourceNotFound(ref cause) => cause,
StopStackError::Validation(ref cause) => cause,
StopStackError::Credentials(ref err) => err.description(),
StopStackError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StopStackError::ParseError(ref cause) => cause,
StopStackError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> TagResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return TagResourceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return TagResourceError::Validation(error_message.to_string());
}
_ => {}
}
}
return TagResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for TagResourceError {
fn from(err: serde_json::error::Error) -> TagResourceError {
TagResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for TagResourceError {
fn from(err: CredentialsError) -> TagResourceError {
TagResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for TagResourceError {
fn from(err: HttpDispatchError) -> TagResourceError {
TagResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for TagResourceError {
fn from(err: io::Error) -> TagResourceError {
TagResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for TagResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for TagResourceError {
fn description(&self) -> &str {
match *self {
TagResourceError::ResourceNotFound(ref cause) => cause,
TagResourceError::Validation(ref cause) => cause,
TagResourceError::Credentials(ref err) => err.description(),
TagResourceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
TagResourceError::ParseError(ref cause) => cause,
TagResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UnassignInstanceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UnassignInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> UnassignInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return UnassignInstanceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return UnassignInstanceError::Validation(error_message.to_string());
}
_ => {}
}
}
return UnassignInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UnassignInstanceError {
fn from(err: serde_json::error::Error) -> UnassignInstanceError {
UnassignInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UnassignInstanceError {
fn from(err: CredentialsError) -> UnassignInstanceError {
UnassignInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for UnassignInstanceError {
fn from(err: HttpDispatchError) -> UnassignInstanceError {
UnassignInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for UnassignInstanceError {
fn from(err: io::Error) -> UnassignInstanceError {
UnassignInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UnassignInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UnassignInstanceError {
fn description(&self) -> &str {
match *self {
UnassignInstanceError::ResourceNotFound(ref cause) => cause,
UnassignInstanceError::Validation(ref cause) => cause,
UnassignInstanceError::Credentials(ref err) => err.description(),
UnassignInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UnassignInstanceError::ParseError(ref cause) => cause,
UnassignInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UnassignVolumeError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UnassignVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> UnassignVolumeError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return UnassignVolumeError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return UnassignVolumeError::Validation(error_message.to_string());
}
_ => {}
}
}
return UnassignVolumeError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UnassignVolumeError {
fn from(err: serde_json::error::Error) -> UnassignVolumeError {
UnassignVolumeError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UnassignVolumeError {
fn from(err: CredentialsError) -> UnassignVolumeError {
UnassignVolumeError::Credentials(err)
}
}
impl From<HttpDispatchError> for UnassignVolumeError {
fn from(err: HttpDispatchError) -> UnassignVolumeError {
UnassignVolumeError::HttpDispatch(err)
}
}
impl From<io::Error> for UnassignVolumeError {
fn from(err: io::Error) -> UnassignVolumeError {
UnassignVolumeError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UnassignVolumeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UnassignVolumeError {
fn description(&self) -> &str {
match *self {
UnassignVolumeError::ResourceNotFound(ref cause) => cause,
UnassignVolumeError::Validation(ref cause) => cause,
UnassignVolumeError::Credentials(ref err) => err.description(),
UnassignVolumeError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UnassignVolumeError::ParseError(ref cause) => cause,
UnassignVolumeError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> UntagResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return UntagResourceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return UntagResourceError::Validation(error_message.to_string());
}
_ => {}
}
}
return UntagResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UntagResourceError {
fn from(err: serde_json::error::Error) -> UntagResourceError {
UntagResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UntagResourceError {
fn from(err: CredentialsError) -> UntagResourceError {
UntagResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for UntagResourceError {
fn from(err: HttpDispatchError) -> UntagResourceError {
UntagResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for UntagResourceError {
fn from(err: io::Error) -> UntagResourceError {
UntagResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UntagResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UntagResourceError {
fn description(&self) -> &str {
match *self {
UntagResourceError::ResourceNotFound(ref cause) => cause,
UntagResourceError::Validation(ref cause) => cause,
UntagResourceError::Credentials(ref err) => err.description(),
UntagResourceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UntagResourceError::ParseError(ref cause) => cause,
UntagResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateAppError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateAppError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateAppError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return UpdateAppError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return UpdateAppError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateAppError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateAppError {
fn from(err: serde_json::error::Error) -> UpdateAppError {
UpdateAppError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateAppError {
fn from(err: CredentialsError) -> UpdateAppError {
UpdateAppError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateAppError {
fn from(err: HttpDispatchError) -> UpdateAppError {
UpdateAppError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateAppError {
fn from(err: io::Error) -> UpdateAppError {
UpdateAppError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateAppError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateAppError {
fn description(&self) -> &str {
match *self {
UpdateAppError::ResourceNotFound(ref cause) => cause,
UpdateAppError::Validation(ref cause) => cause,
UpdateAppError::Credentials(ref err) => err.description(),
UpdateAppError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateAppError::ParseError(ref cause) => cause,
UpdateAppError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateElasticIpError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateElasticIpError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateElasticIpError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return UpdateElasticIpError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return UpdateElasticIpError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateElasticIpError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateElasticIpError {
fn from(err: serde_json::error::Error) -> UpdateElasticIpError {
UpdateElasticIpError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateElasticIpError {
fn from(err: CredentialsError) -> UpdateElasticIpError {
UpdateElasticIpError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateElasticIpError {
fn from(err: HttpDispatchError) -> UpdateElasticIpError {
UpdateElasticIpError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateElasticIpError {
fn from(err: io::Error) -> UpdateElasticIpError {
UpdateElasticIpError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateElasticIpError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateElasticIpError {
fn description(&self) -> &str {
match *self {
UpdateElasticIpError::ResourceNotFound(ref cause) => cause,
UpdateElasticIpError::Validation(ref cause) => cause,
UpdateElasticIpError::Credentials(ref err) => err.description(),
UpdateElasticIpError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateElasticIpError::ParseError(ref cause) => cause,
UpdateElasticIpError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateInstanceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return UpdateInstanceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return UpdateInstanceError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateInstanceError {
fn from(err: serde_json::error::Error) -> UpdateInstanceError {
UpdateInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateInstanceError {
fn from(err: CredentialsError) -> UpdateInstanceError {
UpdateInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateInstanceError {
fn from(err: HttpDispatchError) -> UpdateInstanceError {
UpdateInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateInstanceError {
fn from(err: io::Error) -> UpdateInstanceError {
UpdateInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateInstanceError {
fn description(&self) -> &str {
match *self {
UpdateInstanceError::ResourceNotFound(ref cause) => cause,
UpdateInstanceError::Validation(ref cause) => cause,
UpdateInstanceError::Credentials(ref err) => err.description(),
UpdateInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateInstanceError::ParseError(ref cause) => cause,
UpdateInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateLayerError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateLayerError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateLayerError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return UpdateLayerError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return UpdateLayerError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateLayerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateLayerError {
fn from(err: serde_json::error::Error) -> UpdateLayerError {
UpdateLayerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateLayerError {
fn from(err: CredentialsError) -> UpdateLayerError {
UpdateLayerError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateLayerError {
fn from(err: HttpDispatchError) -> UpdateLayerError {
UpdateLayerError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateLayerError {
fn from(err: io::Error) -> UpdateLayerError {
UpdateLayerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateLayerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateLayerError {
fn description(&self) -> &str {
match *self {
UpdateLayerError::ResourceNotFound(ref cause) => cause,
UpdateLayerError::Validation(ref cause) => cause,
UpdateLayerError::Credentials(ref err) => err.description(),
UpdateLayerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateLayerError::ParseError(ref cause) => cause,
UpdateLayerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateMyUserProfileError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateMyUserProfileError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateMyUserProfileError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ValidationException" => {
return UpdateMyUserProfileError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateMyUserProfileError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateMyUserProfileError {
fn from(err: serde_json::error::Error) -> UpdateMyUserProfileError {
UpdateMyUserProfileError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateMyUserProfileError {
fn from(err: CredentialsError) -> UpdateMyUserProfileError {
UpdateMyUserProfileError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateMyUserProfileError {
fn from(err: HttpDispatchError) -> UpdateMyUserProfileError {
UpdateMyUserProfileError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateMyUserProfileError {
fn from(err: io::Error) -> UpdateMyUserProfileError {
UpdateMyUserProfileError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateMyUserProfileError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateMyUserProfileError {
fn description(&self) -> &str {
match *self {
UpdateMyUserProfileError::Validation(ref cause) => cause,
UpdateMyUserProfileError::Credentials(ref err) => err.description(),
UpdateMyUserProfileError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateMyUserProfileError::ParseError(ref cause) => cause,
UpdateMyUserProfileError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateRdsDbInstanceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateRdsDbInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateRdsDbInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return UpdateRdsDbInstanceError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return UpdateRdsDbInstanceError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateRdsDbInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateRdsDbInstanceError {
fn from(err: serde_json::error::Error) -> UpdateRdsDbInstanceError {
UpdateRdsDbInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateRdsDbInstanceError {
fn from(err: CredentialsError) -> UpdateRdsDbInstanceError {
UpdateRdsDbInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateRdsDbInstanceError {
fn from(err: HttpDispatchError) -> UpdateRdsDbInstanceError {
UpdateRdsDbInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateRdsDbInstanceError {
fn from(err: io::Error) -> UpdateRdsDbInstanceError {
UpdateRdsDbInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateRdsDbInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateRdsDbInstanceError {
fn description(&self) -> &str {
match *self {
UpdateRdsDbInstanceError::ResourceNotFound(ref cause) => cause,
UpdateRdsDbInstanceError::Validation(ref cause) => cause,
UpdateRdsDbInstanceError::Credentials(ref err) => err.description(),
UpdateRdsDbInstanceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateRdsDbInstanceError::ParseError(ref cause) => cause,
UpdateRdsDbInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateStackError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateStackError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateStackError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return UpdateStackError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return UpdateStackError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateStackError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateStackError {
fn from(err: serde_json::error::Error) -> UpdateStackError {
UpdateStackError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateStackError {
fn from(err: CredentialsError) -> UpdateStackError {
UpdateStackError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateStackError {
fn from(err: HttpDispatchError) -> UpdateStackError {
UpdateStackError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateStackError {
fn from(err: io::Error) -> UpdateStackError {
UpdateStackError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateStackError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateStackError {
fn description(&self) -> &str {
match *self {
UpdateStackError::ResourceNotFound(ref cause) => cause,
UpdateStackError::Validation(ref cause) => cause,
UpdateStackError::Credentials(ref err) => err.description(),
UpdateStackError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateStackError::ParseError(ref cause) => cause,
UpdateStackError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateUserProfileError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateUserProfileError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateUserProfileError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return UpdateUserProfileError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return UpdateUserProfileError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateUserProfileError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateUserProfileError {
fn from(err: serde_json::error::Error) -> UpdateUserProfileError {
UpdateUserProfileError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateUserProfileError {
fn from(err: CredentialsError) -> UpdateUserProfileError {
UpdateUserProfileError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateUserProfileError {
fn from(err: HttpDispatchError) -> UpdateUserProfileError {
UpdateUserProfileError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateUserProfileError {
fn from(err: io::Error) -> UpdateUserProfileError {
UpdateUserProfileError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateUserProfileError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateUserProfileError {
fn description(&self) -> &str {
match *self {
UpdateUserProfileError::ResourceNotFound(ref cause) => cause,
UpdateUserProfileError::Validation(ref cause) => cause,
UpdateUserProfileError::Credentials(ref err) => err.description(),
UpdateUserProfileError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateUserProfileError::ParseError(ref cause) => cause,
UpdateUserProfileError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateVolumeError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateVolumeError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return UpdateVolumeError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return UpdateVolumeError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateVolumeError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateVolumeError {
fn from(err: serde_json::error::Error) -> UpdateVolumeError {
UpdateVolumeError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateVolumeError {
fn from(err: CredentialsError) -> UpdateVolumeError {
UpdateVolumeError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateVolumeError {
fn from(err: HttpDispatchError) -> UpdateVolumeError {
UpdateVolumeError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateVolumeError {
fn from(err: io::Error) -> UpdateVolumeError {
UpdateVolumeError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateVolumeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateVolumeError {
fn description(&self) -> &str {
match *self {
UpdateVolumeError::ResourceNotFound(ref cause) => cause,
UpdateVolumeError::Validation(ref cause) => cause,
UpdateVolumeError::Credentials(ref err) => err.description(),
UpdateVolumeError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateVolumeError::ParseError(ref cause) => cause,
UpdateVolumeError::Unknown(_) => "unknown error",
}
}
}
pub trait OpsWorks {
fn assign_instance(
&self,
input: AssignInstanceRequest,
) -> RusotoFuture<(), AssignInstanceError>;
fn assign_volume(&self, input: AssignVolumeRequest) -> RusotoFuture<(), AssignVolumeError>;
fn associate_elastic_ip(
&self,
input: AssociateElasticIpRequest,
) -> RusotoFuture<(), AssociateElasticIpError>;
fn attach_elastic_load_balancer(
&self,
input: AttachElasticLoadBalancerRequest,
) -> RusotoFuture<(), AttachElasticLoadBalancerError>;
fn clone_stack(
&self,
input: CloneStackRequest,
) -> RusotoFuture<CloneStackResult, CloneStackError>;
fn create_app(&self, input: CreateAppRequest) -> RusotoFuture<CreateAppResult, CreateAppError>;
fn create_deployment(
&self,
input: CreateDeploymentRequest,
) -> RusotoFuture<CreateDeploymentResult, CreateDeploymentError>;
fn create_instance(
&self,
input: CreateInstanceRequest,
) -> RusotoFuture<CreateInstanceResult, CreateInstanceError>;
fn create_layer(
&self,
input: CreateLayerRequest,
) -> RusotoFuture<CreateLayerResult, CreateLayerError>;
fn create_stack(
&self,
input: CreateStackRequest,
) -> RusotoFuture<CreateStackResult, CreateStackError>;
fn create_user_profile(
&self,
input: CreateUserProfileRequest,
) -> RusotoFuture<CreateUserProfileResult, CreateUserProfileError>;
fn delete_app(&self, input: DeleteAppRequest) -> RusotoFuture<(), DeleteAppError>;
fn delete_instance(
&self,
input: DeleteInstanceRequest,
) -> RusotoFuture<(), DeleteInstanceError>;
fn delete_layer(&self, input: DeleteLayerRequest) -> RusotoFuture<(), DeleteLayerError>;
fn delete_stack(&self, input: DeleteStackRequest) -> RusotoFuture<(), DeleteStackError>;
fn delete_user_profile(
&self,
input: DeleteUserProfileRequest,
) -> RusotoFuture<(), DeleteUserProfileError>;
fn deregister_ecs_cluster(
&self,
input: DeregisterEcsClusterRequest,
) -> RusotoFuture<(), DeregisterEcsClusterError>;
fn deregister_elastic_ip(
&self,
input: DeregisterElasticIpRequest,
) -> RusotoFuture<(), DeregisterElasticIpError>;
fn deregister_instance(
&self,
input: DeregisterInstanceRequest,
) -> RusotoFuture<(), DeregisterInstanceError>;
fn deregister_rds_db_instance(
&self,
input: DeregisterRdsDbInstanceRequest,
) -> RusotoFuture<(), DeregisterRdsDbInstanceError>;
fn deregister_volume(
&self,
input: DeregisterVolumeRequest,
) -> RusotoFuture<(), DeregisterVolumeError>;
fn describe_agent_versions(
&self,
input: DescribeAgentVersionsRequest,
) -> RusotoFuture<DescribeAgentVersionsResult, DescribeAgentVersionsError>;
fn describe_apps(
&self,
input: DescribeAppsRequest,
) -> RusotoFuture<DescribeAppsResult, DescribeAppsError>;
fn describe_commands(
&self,
input: DescribeCommandsRequest,
) -> RusotoFuture<DescribeCommandsResult, DescribeCommandsError>;
fn describe_deployments(
&self,
input: DescribeDeploymentsRequest,
) -> RusotoFuture<DescribeDeploymentsResult, DescribeDeploymentsError>;
fn describe_ecs_clusters(
&self,
input: DescribeEcsClustersRequest,
) -> RusotoFuture<DescribeEcsClustersResult, DescribeEcsClustersError>;
fn describe_elastic_ips(
&self,
input: DescribeElasticIpsRequest,
) -> RusotoFuture<DescribeElasticIpsResult, DescribeElasticIpsError>;
fn describe_elastic_load_balancers(
&self,
input: DescribeElasticLoadBalancersRequest,
) -> RusotoFuture<DescribeElasticLoadBalancersResult, DescribeElasticLoadBalancersError>;
fn describe_instances(
&self,
input: DescribeInstancesRequest,
) -> RusotoFuture<DescribeInstancesResult, DescribeInstancesError>;
fn describe_layers(
&self,
input: DescribeLayersRequest,
) -> RusotoFuture<DescribeLayersResult, DescribeLayersError>;
fn describe_load_based_auto_scaling(
&self,
input: DescribeLoadBasedAutoScalingRequest,
) -> RusotoFuture<DescribeLoadBasedAutoScalingResult, DescribeLoadBasedAutoScalingError>;
fn describe_my_user_profile(
&self,
) -> RusotoFuture<DescribeMyUserProfileResult, DescribeMyUserProfileError>;
fn describe_operating_systems(
&self,
) -> RusotoFuture<DescribeOperatingSystemsResponse, DescribeOperatingSystemsError>;
fn describe_permissions(
&self,
input: DescribePermissionsRequest,
) -> RusotoFuture<DescribePermissionsResult, DescribePermissionsError>;
fn describe_raid_arrays(
&self,
input: DescribeRaidArraysRequest,
) -> RusotoFuture<DescribeRaidArraysResult, DescribeRaidArraysError>;
fn describe_rds_db_instances(
&self,
input: DescribeRdsDbInstancesRequest,
) -> RusotoFuture<DescribeRdsDbInstancesResult, DescribeRdsDbInstancesError>;
fn describe_service_errors(
&self,
input: DescribeServiceErrorsRequest,
) -> RusotoFuture<DescribeServiceErrorsResult, DescribeServiceErrorsError>;
fn describe_stack_provisioning_parameters(
&self,
input: DescribeStackProvisioningParametersRequest,
) -> RusotoFuture<
DescribeStackProvisioningParametersResult,
DescribeStackProvisioningParametersError,
>;
fn describe_stack_summary(
&self,
input: DescribeStackSummaryRequest,
) -> RusotoFuture<DescribeStackSummaryResult, DescribeStackSummaryError>;
fn describe_stacks(
&self,
input: DescribeStacksRequest,
) -> RusotoFuture<DescribeStacksResult, DescribeStacksError>;
fn describe_time_based_auto_scaling(
&self,
input: DescribeTimeBasedAutoScalingRequest,
) -> RusotoFuture<DescribeTimeBasedAutoScalingResult, DescribeTimeBasedAutoScalingError>;
fn describe_user_profiles(
&self,
input: DescribeUserProfilesRequest,
) -> RusotoFuture<DescribeUserProfilesResult, DescribeUserProfilesError>;
fn describe_volumes(
&self,
input: DescribeVolumesRequest,
) -> RusotoFuture<DescribeVolumesResult, DescribeVolumesError>;
fn detach_elastic_load_balancer(
&self,
input: DetachElasticLoadBalancerRequest,
) -> RusotoFuture<(), DetachElasticLoadBalancerError>;
fn disassociate_elastic_ip(
&self,
input: DisassociateElasticIpRequest,
) -> RusotoFuture<(), DisassociateElasticIpError>;
fn get_hostname_suggestion(
&self,
input: GetHostnameSuggestionRequest,
) -> RusotoFuture<GetHostnameSuggestionResult, GetHostnameSuggestionError>;
fn grant_access(
&self,
input: GrantAccessRequest,
) -> RusotoFuture<GrantAccessResult, GrantAccessError>;
fn list_tags(&self, input: ListTagsRequest) -> RusotoFuture<ListTagsResult, ListTagsError>;
fn reboot_instance(
&self,
input: RebootInstanceRequest,
) -> RusotoFuture<(), RebootInstanceError>;
fn register_ecs_cluster(
&self,
input: RegisterEcsClusterRequest,
) -> RusotoFuture<RegisterEcsClusterResult, RegisterEcsClusterError>;
fn register_elastic_ip(
&self,
input: RegisterElasticIpRequest,
) -> RusotoFuture<RegisterElasticIpResult, RegisterElasticIpError>;
fn register_instance(
&self,
input: RegisterInstanceRequest,
) -> RusotoFuture<RegisterInstanceResult, RegisterInstanceError>;
fn register_rds_db_instance(
&self,
input: RegisterRdsDbInstanceRequest,
) -> RusotoFuture<(), RegisterRdsDbInstanceError>;
fn register_volume(
&self,
input: RegisterVolumeRequest,
) -> RusotoFuture<RegisterVolumeResult, RegisterVolumeError>;
fn set_load_based_auto_scaling(
&self,
input: SetLoadBasedAutoScalingRequest,
) -> RusotoFuture<(), SetLoadBasedAutoScalingError>;
fn set_permission(&self, input: SetPermissionRequest) -> RusotoFuture<(), SetPermissionError>;
fn set_time_based_auto_scaling(
&self,
input: SetTimeBasedAutoScalingRequest,
) -> RusotoFuture<(), SetTimeBasedAutoScalingError>;
fn start_instance(&self, input: StartInstanceRequest) -> RusotoFuture<(), StartInstanceError>;
fn start_stack(&self, input: StartStackRequest) -> RusotoFuture<(), StartStackError>;
fn stop_instance(&self, input: StopInstanceRequest) -> RusotoFuture<(), StopInstanceError>;
fn stop_stack(&self, input: StopStackRequest) -> RusotoFuture<(), StopStackError>;
fn tag_resource(&self, input: TagResourceRequest) -> RusotoFuture<(), TagResourceError>;
fn unassign_instance(
&self,
input: UnassignInstanceRequest,
) -> RusotoFuture<(), UnassignInstanceError>;
fn unassign_volume(
&self,
input: UnassignVolumeRequest,
) -> RusotoFuture<(), UnassignVolumeError>;
fn untag_resource(&self, input: UntagResourceRequest) -> RusotoFuture<(), UntagResourceError>;
fn update_app(&self, input: UpdateAppRequest) -> RusotoFuture<(), UpdateAppError>;
fn update_elastic_ip(
&self,
input: UpdateElasticIpRequest,
) -> RusotoFuture<(), UpdateElasticIpError>;
fn update_instance(
&self,
input: UpdateInstanceRequest,
) -> RusotoFuture<(), UpdateInstanceError>;
fn update_layer(&self, input: UpdateLayerRequest) -> RusotoFuture<(), UpdateLayerError>;
fn update_my_user_profile(
&self,
input: UpdateMyUserProfileRequest,
) -> RusotoFuture<(), UpdateMyUserProfileError>;
fn update_rds_db_instance(
&self,
input: UpdateRdsDbInstanceRequest,
) -> RusotoFuture<(), UpdateRdsDbInstanceError>;
fn update_stack(&self, input: UpdateStackRequest) -> RusotoFuture<(), UpdateStackError>;
fn update_user_profile(
&self,
input: UpdateUserProfileRequest,
) -> RusotoFuture<(), UpdateUserProfileError>;
fn update_volume(&self, input: UpdateVolumeRequest) -> RusotoFuture<(), UpdateVolumeError>;
}
#[derive(Clone)]
pub struct OpsWorksClient {
client: Client,
region: region::Region,
}
impl OpsWorksClient {
pub fn new(region: region::Region) -> OpsWorksClient {
OpsWorksClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> OpsWorksClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
OpsWorksClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl OpsWorks for OpsWorksClient {
fn assign_instance(
&self,
input: AssignInstanceRequest,
) -> RusotoFuture<(), AssignInstanceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.AssignInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(AssignInstanceError::from_response(response))),
)
}
})
}
fn assign_volume(&self, input: AssignVolumeRequest) -> RusotoFuture<(), AssignVolumeError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.AssignVolume");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(AssignVolumeError::from_response(response))),
)
}
})
}
fn associate_elastic_ip(
&self,
input: AssociateElasticIpRequest,
) -> RusotoFuture<(), AssociateElasticIpError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.AssociateElasticIp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(AssociateElasticIpError::from_response(response))),
)
}
})
}
fn attach_elastic_load_balancer(
&self,
input: AttachElasticLoadBalancerRequest,
) -> RusotoFuture<(), AttachElasticLoadBalancerError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"OpsWorks_20130218.AttachElasticLoadBalancer",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(AttachElasticLoadBalancerError::from_response(response))
}))
}
})
}
fn clone_stack(
&self,
input: CloneStackRequest,
) -> RusotoFuture<CloneStackResult, CloneStackError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.CloneStack");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CloneStackResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CloneStackError::from_response(response))),
)
}
})
}
fn create_app(&self, input: CreateAppRequest) -> RusotoFuture<CreateAppResult, CreateAppError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.CreateApp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateAppResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateAppError::from_response(response))),
)
}
})
}
fn create_deployment(
&self,
input: CreateDeploymentRequest,
) -> RusotoFuture<CreateDeploymentResult, CreateDeploymentError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.CreateDeployment");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateDeploymentResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateDeploymentError::from_response(response))),
)
}
})
}
fn create_instance(
&self,
input: CreateInstanceRequest,
) -> RusotoFuture<CreateInstanceResult, CreateInstanceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.CreateInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateInstanceResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateInstanceError::from_response(response))),
)
}
})
}
fn create_layer(
&self,
input: CreateLayerRequest,
) -> RusotoFuture<CreateLayerResult, CreateLayerError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.CreateLayer");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateLayerResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateLayerError::from_response(response))),
)
}
})
}
fn create_stack(
&self,
input: CreateStackRequest,
) -> RusotoFuture<CreateStackResult, CreateStackError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.CreateStack");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateStackResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateStackError::from_response(response))),
)
}
})
}
fn create_user_profile(
&self,
input: CreateUserProfileRequest,
) -> RusotoFuture<CreateUserProfileResult, CreateUserProfileError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.CreateUserProfile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateUserProfileResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateUserProfileError::from_response(response))),
)
}
})
}
fn delete_app(&self, input: DeleteAppRequest) -> RusotoFuture<(), DeleteAppError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DeleteApp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteAppError::from_response(response))),
)
}
})
}
fn delete_instance(
&self,
input: DeleteInstanceRequest,
) -> RusotoFuture<(), DeleteInstanceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DeleteInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteInstanceError::from_response(response))),
)
}
})
}
fn delete_layer(&self, input: DeleteLayerRequest) -> RusotoFuture<(), DeleteLayerError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DeleteLayer");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteLayerError::from_response(response))),
)
}
})
}
fn delete_stack(&self, input: DeleteStackRequest) -> RusotoFuture<(), DeleteStackError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DeleteStack");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteStackError::from_response(response))),
)
}
})
}
fn delete_user_profile(
&self,
input: DeleteUserProfileRequest,
) -> RusotoFuture<(), DeleteUserProfileError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DeleteUserProfile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteUserProfileError::from_response(response))),
)
}
})
}
fn deregister_ecs_cluster(
&self,
input: DeregisterEcsClusterRequest,
) -> RusotoFuture<(), DeregisterEcsClusterError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DeregisterEcsCluster");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeregisterEcsClusterError::from_response(response))
}),
)
}
})
}
fn deregister_elastic_ip(
&self,
input: DeregisterElasticIpRequest,
) -> RusotoFuture<(), DeregisterElasticIpError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DeregisterElasticIp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeregisterElasticIpError::from_response(response))
}),
)
}
})
}
fn deregister_instance(
&self,
input: DeregisterInstanceRequest,
) -> RusotoFuture<(), DeregisterInstanceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DeregisterInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeregisterInstanceError::from_response(response))),
)
}
})
}
fn deregister_rds_db_instance(
&self,
input: DeregisterRdsDbInstanceRequest,
) -> RusotoFuture<(), DeregisterRdsDbInstanceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DeregisterRdsDbInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeregisterRdsDbInstanceError::from_response(response))
}))
}
})
}
fn deregister_volume(
&self,
input: DeregisterVolumeRequest,
) -> RusotoFuture<(), DeregisterVolumeError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DeregisterVolume");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeregisterVolumeError::from_response(response))),
)
}
})
}
fn describe_agent_versions(
&self,
input: DescribeAgentVersionsRequest,
) -> RusotoFuture<DescribeAgentVersionsResult, DescribeAgentVersionsError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeAgentVersions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeAgentVersionsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeAgentVersionsError::from_response(response))
}),
)
}
})
}
fn describe_apps(
&self,
input: DescribeAppsRequest,
) -> RusotoFuture<DescribeAppsResult, DescribeAppsError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeApps");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeAppsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeAppsError::from_response(response))),
)
}
})
}
fn describe_commands(
&self,
input: DescribeCommandsRequest,
) -> RusotoFuture<DescribeCommandsResult, DescribeCommandsError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeCommands");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeCommandsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeCommandsError::from_response(response))),
)
}
})
}
fn describe_deployments(
&self,
input: DescribeDeploymentsRequest,
) -> RusotoFuture<DescribeDeploymentsResult, DescribeDeploymentsError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeDeployments");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeDeploymentsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeDeploymentsError::from_response(response))
}),
)
}
})
}
fn describe_ecs_clusters(
&self,
input: DescribeEcsClustersRequest,
) -> RusotoFuture<DescribeEcsClustersResult, DescribeEcsClustersError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeEcsClusters");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeEcsClustersResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeEcsClustersError::from_response(response))
}),
)
}
})
}
fn describe_elastic_ips(
&self,
input: DescribeElasticIpsRequest,
) -> RusotoFuture<DescribeElasticIpsResult, DescribeElasticIpsError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeElasticIps");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeElasticIpsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeElasticIpsError::from_response(response))),
)
}
})
}
fn describe_elastic_load_balancers(
&self,
input: DescribeElasticLoadBalancersRequest,
) -> RusotoFuture<DescribeElasticLoadBalancersResult, DescribeElasticLoadBalancersError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"OpsWorks_20130218.DescribeElasticLoadBalancers",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeElasticLoadBalancersResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeElasticLoadBalancersError::from_response(response))
}))
}
})
}
fn describe_instances(
&self,
input: DescribeInstancesRequest,
) -> RusotoFuture<DescribeInstancesResult, DescribeInstancesError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeInstances");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeInstancesResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeInstancesError::from_response(response))),
)
}
})
}
fn describe_layers(
&self,
input: DescribeLayersRequest,
) -> RusotoFuture<DescribeLayersResult, DescribeLayersError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeLayers");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeLayersResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeLayersError::from_response(response))),
)
}
})
}
fn describe_load_based_auto_scaling(
&self,
input: DescribeLoadBasedAutoScalingRequest,
) -> RusotoFuture<DescribeLoadBasedAutoScalingResult, DescribeLoadBasedAutoScalingError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"OpsWorks_20130218.DescribeLoadBasedAutoScaling",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeLoadBasedAutoScalingResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeLoadBasedAutoScalingError::from_response(response))
}))
}
})
}
fn describe_my_user_profile(
&self,
) -> RusotoFuture<DescribeMyUserProfileResult, DescribeMyUserProfileError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeMyUserProfile");
request.set_payload(Some(b"{}".to_vec()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeMyUserProfileResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeMyUserProfileError::from_response(response))
}),
)
}
})
}
fn describe_operating_systems(
&self,
) -> RusotoFuture<DescribeOperatingSystemsResponse, DescribeOperatingSystemsError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeOperatingSystems");
request.set_payload(Some(b"{}".to_vec()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeOperatingSystemsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeOperatingSystemsError::from_response(response))
}))
}
})
}
fn describe_permissions(
&self,
input: DescribePermissionsRequest,
) -> RusotoFuture<DescribePermissionsResult, DescribePermissionsError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribePermissions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribePermissionsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribePermissionsError::from_response(response))
}),
)
}
})
}
fn describe_raid_arrays(
&self,
input: DescribeRaidArraysRequest,
) -> RusotoFuture<DescribeRaidArraysResult, DescribeRaidArraysError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeRaidArrays");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeRaidArraysResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeRaidArraysError::from_response(response))),
)
}
})
}
fn describe_rds_db_instances(
&self,
input: DescribeRdsDbInstancesRequest,
) -> RusotoFuture<DescribeRdsDbInstancesResult, DescribeRdsDbInstancesError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeRdsDbInstances");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeRdsDbInstancesResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeRdsDbInstancesError::from_response(response))
}),
)
}
})
}
fn describe_service_errors(
&self,
input: DescribeServiceErrorsRequest,
) -> RusotoFuture<DescribeServiceErrorsResult, DescribeServiceErrorsError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeServiceErrors");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeServiceErrorsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeServiceErrorsError::from_response(response))
}),
)
}
})
}
fn describe_stack_provisioning_parameters(
&self,
input: DescribeStackProvisioningParametersRequest,
) -> RusotoFuture<
DescribeStackProvisioningParametersResult,
DescribeStackProvisioningParametersError,
> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"OpsWorks_20130218.DescribeStackProvisioningParameters",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeStackProvisioningParametersResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeStackProvisioningParametersError::from_response(
response,
))
}))
}
})
}
fn describe_stack_summary(
&self,
input: DescribeStackSummaryRequest,
) -> RusotoFuture<DescribeStackSummaryResult, DescribeStackSummaryError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeStackSummary");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeStackSummaryResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeStackSummaryError::from_response(response))
}),
)
}
})
}
fn describe_stacks(
&self,
input: DescribeStacksRequest,
) -> RusotoFuture<DescribeStacksResult, DescribeStacksError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeStacks");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeStacksResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeStacksError::from_response(response))),
)
}
})
}
fn describe_time_based_auto_scaling(
&self,
input: DescribeTimeBasedAutoScalingRequest,
) -> RusotoFuture<DescribeTimeBasedAutoScalingResult, DescribeTimeBasedAutoScalingError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"OpsWorks_20130218.DescribeTimeBasedAutoScaling",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeTimeBasedAutoScalingResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeTimeBasedAutoScalingError::from_response(response))
}))
}
})
}
fn describe_user_profiles(
&self,
input: DescribeUserProfilesRequest,
) -> RusotoFuture<DescribeUserProfilesResult, DescribeUserProfilesError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeUserProfiles");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeUserProfilesResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeUserProfilesError::from_response(response))
}),
)
}
})
}
fn describe_volumes(
&self,
input: DescribeVolumesRequest,
) -> RusotoFuture<DescribeVolumesResult, DescribeVolumesError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DescribeVolumes");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeVolumesResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeVolumesError::from_response(response))),
)
}
})
}
fn detach_elastic_load_balancer(
&self,
input: DetachElasticLoadBalancerRequest,
) -> RusotoFuture<(), DetachElasticLoadBalancerError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"OpsWorks_20130218.DetachElasticLoadBalancer",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DetachElasticLoadBalancerError::from_response(response))
}))
}
})
}
fn disassociate_elastic_ip(
&self,
input: DisassociateElasticIpRequest,
) -> RusotoFuture<(), DisassociateElasticIpError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.DisassociateElasticIp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DisassociateElasticIpError::from_response(response))
}),
)
}
})
}
fn get_hostname_suggestion(
&self,
input: GetHostnameSuggestionRequest,
) -> RusotoFuture<GetHostnameSuggestionResult, GetHostnameSuggestionError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.GetHostnameSuggestion");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<GetHostnameSuggestionResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetHostnameSuggestionError::from_response(response))
}),
)
}
})
}
fn grant_access(
&self,
input: GrantAccessRequest,
) -> RusotoFuture<GrantAccessResult, GrantAccessError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.GrantAccess");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<GrantAccessResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GrantAccessError::from_response(response))),
)
}
})
}
fn list_tags(&self, input: ListTagsRequest) -> RusotoFuture<ListTagsResult, ListTagsError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.ListTags");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListTagsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListTagsError::from_response(response))),
)
}
})
}
fn reboot_instance(
&self,
input: RebootInstanceRequest,
) -> RusotoFuture<(), RebootInstanceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.RebootInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RebootInstanceError::from_response(response))),
)
}
})
}
fn register_ecs_cluster(
&self,
input: RegisterEcsClusterRequest,
) -> RusotoFuture<RegisterEcsClusterResult, RegisterEcsClusterError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.RegisterEcsCluster");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<RegisterEcsClusterResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RegisterEcsClusterError::from_response(response))),
)
}
})
}
fn register_elastic_ip(
&self,
input: RegisterElasticIpRequest,
) -> RusotoFuture<RegisterElasticIpResult, RegisterElasticIpError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.RegisterElasticIp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<RegisterElasticIpResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RegisterElasticIpError::from_response(response))),
)
}
})
}
fn register_instance(
&self,
input: RegisterInstanceRequest,
) -> RusotoFuture<RegisterInstanceResult, RegisterInstanceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.RegisterInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<RegisterInstanceResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RegisterInstanceError::from_response(response))),
)
}
})
}
fn register_rds_db_instance(
&self,
input: RegisterRdsDbInstanceRequest,
) -> RusotoFuture<(), RegisterRdsDbInstanceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.RegisterRdsDbInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(RegisterRdsDbInstanceError::from_response(response))
}),
)
}
})
}
fn register_volume(
&self,
input: RegisterVolumeRequest,
) -> RusotoFuture<RegisterVolumeResult, RegisterVolumeError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.RegisterVolume");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<RegisterVolumeResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RegisterVolumeError::from_response(response))),
)
}
})
}
fn set_load_based_auto_scaling(
&self,
input: SetLoadBasedAutoScalingRequest,
) -> RusotoFuture<(), SetLoadBasedAutoScalingError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.SetLoadBasedAutoScaling");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(SetLoadBasedAutoScalingError::from_response(response))
}))
}
})
}
fn set_permission(&self, input: SetPermissionRequest) -> RusotoFuture<(), SetPermissionError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.SetPermission");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(SetPermissionError::from_response(response))),
)
}
})
}
fn set_time_based_auto_scaling(
&self,
input: SetTimeBasedAutoScalingRequest,
) -> RusotoFuture<(), SetTimeBasedAutoScalingError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.SetTimeBasedAutoScaling");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(SetTimeBasedAutoScalingError::from_response(response))
}))
}
})
}
fn start_instance(&self, input: StartInstanceRequest) -> RusotoFuture<(), StartInstanceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.StartInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StartInstanceError::from_response(response))),
)
}
})
}
fn start_stack(&self, input: StartStackRequest) -> RusotoFuture<(), StartStackError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.StartStack");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StartStackError::from_response(response))),
)
}
})
}
fn stop_instance(&self, input: StopInstanceRequest) -> RusotoFuture<(), StopInstanceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.StopInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StopInstanceError::from_response(response))),
)
}
})
}
fn stop_stack(&self, input: StopStackRequest) -> RusotoFuture<(), StopStackError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.StopStack");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StopStackError::from_response(response))),
)
}
})
}
fn tag_resource(&self, input: TagResourceRequest) -> RusotoFuture<(), TagResourceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(TagResourceError::from_response(response))),
)
}
})
}
fn unassign_instance(
&self,
input: UnassignInstanceRequest,
) -> RusotoFuture<(), UnassignInstanceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.UnassignInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UnassignInstanceError::from_response(response))),
)
}
})
}
fn unassign_volume(
&self,
input: UnassignVolumeRequest,
) -> RusotoFuture<(), UnassignVolumeError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.UnassignVolume");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UnassignVolumeError::from_response(response))),
)
}
})
}
fn untag_resource(&self, input: UntagResourceRequest) -> RusotoFuture<(), UntagResourceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UntagResourceError::from_response(response))),
)
}
})
}
fn update_app(&self, input: UpdateAppRequest) -> RusotoFuture<(), UpdateAppError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.UpdateApp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateAppError::from_response(response))),
)
}
})
}
fn update_elastic_ip(
&self,
input: UpdateElasticIpRequest,
) -> RusotoFuture<(), UpdateElasticIpError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.UpdateElasticIp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateElasticIpError::from_response(response))),
)
}
})
}
fn update_instance(
&self,
input: UpdateInstanceRequest,
) -> RusotoFuture<(), UpdateInstanceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.UpdateInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateInstanceError::from_response(response))),
)
}
})
}
fn update_layer(&self, input: UpdateLayerRequest) -> RusotoFuture<(), UpdateLayerError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.UpdateLayer");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateLayerError::from_response(response))),
)
}
})
}
fn update_my_user_profile(
&self,
input: UpdateMyUserProfileRequest,
) -> RusotoFuture<(), UpdateMyUserProfileError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.UpdateMyUserProfile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(UpdateMyUserProfileError::from_response(response))
}),
)
}
})
}
fn update_rds_db_instance(
&self,
input: UpdateRdsDbInstanceRequest,
) -> RusotoFuture<(), UpdateRdsDbInstanceError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.UpdateRdsDbInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(UpdateRdsDbInstanceError::from_response(response))
}),
)
}
})
}
fn update_stack(&self, input: UpdateStackRequest) -> RusotoFuture<(), UpdateStackError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.UpdateStack");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateStackError::from_response(response))),
)
}
})
}
fn update_user_profile(
&self,
input: UpdateUserProfileRequest,
) -> RusotoFuture<(), UpdateUserProfileError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.UpdateUserProfile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateUserProfileError::from_response(response))),
)
}
})
}
fn update_volume(&self, input: UpdateVolumeRequest) -> RusotoFuture<(), UpdateVolumeError> {
let mut request = SignedRequest::new("POST", "opsworks", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "OpsWorks_20130218.UpdateVolume");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateVolumeError::from_response(response))),
)
}
})
}
}
#[cfg(test)]
mod protocol_tests {}