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 AccountQuota {
#[serde(rename = "AccountQuotaName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_quota_name: Option<String>,
#[serde(rename = "Max")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max: Option<i64>,
#[serde(rename = "Used")]
#[serde(skip_serializing_if = "Option::is_none")]
pub used: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AddTagsToResourceMessage {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AddTagsToResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AvailabilityZone {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Certificate {
#[serde(rename = "CertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
#[serde(rename = "CertificateCreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_creation_date: Option<f64>,
#[serde(rename = "CertificateIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_identifier: Option<String>,
#[serde(rename = "CertificateOwner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_owner: Option<String>,
#[serde(rename = "CertificatePem")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_pem: Option<String>,
#[serde(rename = "CertificateWallet")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_wallet: Option<Vec<u8>>,
#[serde(rename = "KeyLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_length: Option<i64>,
#[serde(rename = "SigningAlgorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signing_algorithm: Option<String>,
#[serde(rename = "ValidFromDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub valid_from_date: Option<f64>,
#[serde(rename = "ValidToDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub valid_to_date: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Connection {
#[serde(rename = "EndpointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_arn: Option<String>,
#[serde(rename = "EndpointIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_identifier: Option<String>,
#[serde(rename = "LastFailureMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_failure_message: Option<String>,
#[serde(rename = "ReplicationInstanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_arn: Option<String>,
#[serde(rename = "ReplicationInstanceIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_identifier: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateEndpointMessage {
#[serde(rename = "CertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
#[serde(rename = "DatabaseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database_name: Option<String>,
#[serde(rename = "DmsTransferSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dms_transfer_settings: Option<DmsTransferSettings>,
#[serde(rename = "DynamoDbSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamo_db_settings: Option<DynamoDbSettings>,
#[serde(rename = "EndpointIdentifier")]
pub endpoint_identifier: String,
#[serde(rename = "EndpointType")]
pub endpoint_type: String,
#[serde(rename = "EngineName")]
pub engine_name: String,
#[serde(rename = "ExternalTableDefinition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external_table_definition: Option<String>,
#[serde(rename = "ExtraConnectionAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extra_connection_attributes: Option<String>,
#[serde(rename = "KmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "MongoDbSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mongo_db_settings: Option<MongoDbSettings>,
#[serde(rename = "Password")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password: Option<String>,
#[serde(rename = "Port")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port: Option<i64>,
#[serde(rename = "S3Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_settings: Option<S3Settings>,
#[serde(rename = "ServerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_name: Option<String>,
#[serde(rename = "ServiceAccessRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_access_role_arn: Option<String>,
#[serde(rename = "SslMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_mode: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "Username")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateEndpointResponse {
#[serde(rename = "Endpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint: Option<Endpoint>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateEventSubscriptionMessage {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "EventCategories")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_categories: Option<Vec<String>>,
#[serde(rename = "SnsTopicArn")]
pub sns_topic_arn: String,
#[serde(rename = "SourceIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_ids: Option<Vec<String>>,
#[serde(rename = "SourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_type: Option<String>,
#[serde(rename = "SubscriptionName")]
pub subscription_name: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateEventSubscriptionResponse {
#[serde(rename = "EventSubscription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_subscription: Option<EventSubscription>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateReplicationInstanceMessage {
#[serde(rename = "AllocatedStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allocated_storage: Option<i64>,
#[serde(rename = "AutoMinorVersionUpgrade")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_minor_version_upgrade: Option<bool>,
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "EngineVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_version: Option<String>,
#[serde(rename = "KmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "MultiAZ")]
#[serde(skip_serializing_if = "Option::is_none")]
pub multi_az: Option<bool>,
#[serde(rename = "PreferredMaintenanceWindow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_maintenance_window: Option<String>,
#[serde(rename = "PubliclyAccessible")]
#[serde(skip_serializing_if = "Option::is_none")]
pub publicly_accessible: Option<bool>,
#[serde(rename = "ReplicationInstanceClass")]
pub replication_instance_class: String,
#[serde(rename = "ReplicationInstanceIdentifier")]
pub replication_instance_identifier: String,
#[serde(rename = "ReplicationSubnetGroupIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_subnet_group_identifier: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "VpcSecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_security_group_ids: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateReplicationInstanceResponse {
#[serde(rename = "ReplicationInstance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance: Option<ReplicationInstance>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateReplicationSubnetGroupMessage {
#[serde(rename = "ReplicationSubnetGroupDescription")]
pub replication_subnet_group_description: String,
#[serde(rename = "ReplicationSubnetGroupIdentifier")]
pub replication_subnet_group_identifier: String,
#[serde(rename = "SubnetIds")]
pub subnet_ids: Vec<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateReplicationSubnetGroupResponse {
#[serde(rename = "ReplicationSubnetGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_subnet_group: Option<ReplicationSubnetGroup>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateReplicationTaskMessage {
#[serde(rename = "CdcStartPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdc_start_position: Option<String>,
#[serde(rename = "CdcStartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdc_start_time: Option<f64>,
#[serde(rename = "CdcStopPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdc_stop_position: Option<String>,
#[serde(rename = "MigrationType")]
pub migration_type: String,
#[serde(rename = "ReplicationInstanceArn")]
pub replication_instance_arn: String,
#[serde(rename = "ReplicationTaskIdentifier")]
pub replication_task_identifier: String,
#[serde(rename = "ReplicationTaskSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_settings: Option<String>,
#[serde(rename = "SourceEndpointArn")]
pub source_endpoint_arn: String,
#[serde(rename = "TableMappings")]
pub table_mappings: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "TargetEndpointArn")]
pub target_endpoint_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateReplicationTaskResponse {
#[serde(rename = "ReplicationTask")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task: Option<ReplicationTask>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteCertificateMessage {
#[serde(rename = "CertificateArn")]
pub certificate_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteCertificateResponse {
#[serde(rename = "Certificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate: Option<Certificate>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteEndpointMessage {
#[serde(rename = "EndpointArn")]
pub endpoint_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteEndpointResponse {
#[serde(rename = "Endpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint: Option<Endpoint>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteEventSubscriptionMessage {
#[serde(rename = "SubscriptionName")]
pub subscription_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteEventSubscriptionResponse {
#[serde(rename = "EventSubscription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_subscription: Option<EventSubscription>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteReplicationInstanceMessage {
#[serde(rename = "ReplicationInstanceArn")]
pub replication_instance_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteReplicationInstanceResponse {
#[serde(rename = "ReplicationInstance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance: Option<ReplicationInstance>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteReplicationSubnetGroupMessage {
#[serde(rename = "ReplicationSubnetGroupIdentifier")]
pub replication_subnet_group_identifier: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteReplicationSubnetGroupResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteReplicationTaskMessage {
#[serde(rename = "ReplicationTaskArn")]
pub replication_task_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteReplicationTaskResponse {
#[serde(rename = "ReplicationTask")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task: Option<ReplicationTask>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeAccountAttributesMessage {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeAccountAttributesResponse {
#[serde(rename = "AccountQuotas")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_quotas: Option<Vec<AccountQuota>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeCertificatesMessage {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeCertificatesResponse {
#[serde(rename = "Certificates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificates: Option<Vec<Certificate>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeConnectionsMessage {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeConnectionsResponse {
#[serde(rename = "Connections")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connections: Option<Vec<Connection>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeEndpointTypesMessage {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeEndpointTypesResponse {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "SupportedEndpointTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supported_endpoint_types: Option<Vec<SupportedEndpointType>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeEndpointsMessage {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeEndpointsResponse {
#[serde(rename = "Endpoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoints: Option<Vec<Endpoint>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeEventCategoriesMessage {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "SourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeEventCategoriesResponse {
#[serde(rename = "EventCategoryGroupList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_category_group_list: Option<Vec<EventCategoryGroup>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeEventSubscriptionsMessage {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
#[serde(rename = "SubscriptionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeEventSubscriptionsResponse {
#[serde(rename = "EventSubscriptionsList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_subscriptions_list: Option<Vec<EventSubscription>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeEventsMessage {
#[serde(rename = "Duration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub duration: Option<i64>,
#[serde(rename = "EndTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "EventCategories")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_categories: Option<Vec<String>>,
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
#[serde(rename = "SourceIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_identifier: Option<String>,
#[serde(rename = "SourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_type: Option<String>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeEventsResponse {
#[serde(rename = "Events")]
#[serde(skip_serializing_if = "Option::is_none")]
pub events: Option<Vec<Event>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeOrderableReplicationInstancesMessage {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeOrderableReplicationInstancesResponse {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "OrderableReplicationInstances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub orderable_replication_instances: Option<Vec<OrderableReplicationInstance>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeRefreshSchemasStatusMessage {
#[serde(rename = "EndpointArn")]
pub endpoint_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeRefreshSchemasStatusResponse {
#[serde(rename = "RefreshSchemasStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub refresh_schemas_status: Option<RefreshSchemasStatus>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeReplicationInstanceTaskLogsMessage {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
#[serde(rename = "ReplicationInstanceArn")]
pub replication_instance_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeReplicationInstanceTaskLogsResponse {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "ReplicationInstanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_arn: Option<String>,
#[serde(rename = "ReplicationInstanceTaskLogs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_task_logs: Option<Vec<ReplicationInstanceTaskLog>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeReplicationInstancesMessage {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeReplicationInstancesResponse {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "ReplicationInstances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instances: Option<Vec<ReplicationInstance>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeReplicationSubnetGroupsMessage {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeReplicationSubnetGroupsResponse {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "ReplicationSubnetGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_subnet_groups: Option<Vec<ReplicationSubnetGroup>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeReplicationTaskAssessmentResultsMessage {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
#[serde(rename = "ReplicationTaskArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeReplicationTaskAssessmentResultsResponse {
#[serde(rename = "BucketName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket_name: Option<String>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "ReplicationTaskAssessmentResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_assessment_results: Option<Vec<ReplicationTaskAssessmentResult>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeReplicationTasksMessage {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeReplicationTasksResponse {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "ReplicationTasks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_tasks: Option<Vec<ReplicationTask>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeSchemasMessage {
#[serde(rename = "EndpointArn")]
pub endpoint_arn: String,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeSchemasResponse {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "Schemas")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schemas: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeTableStatisticsMessage {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_records: Option<i64>,
#[serde(rename = "ReplicationTaskArn")]
pub replication_task_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeTableStatisticsResponse {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "ReplicationTaskArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_arn: Option<String>,
#[serde(rename = "TableStatistics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_statistics: Option<Vec<TableStatistics>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DmsTransferSettings {
#[serde(rename = "BucketName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket_name: Option<String>,
#[serde(rename = "ServiceAccessRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_access_role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DynamoDbSettings {
#[serde(rename = "ServiceAccessRoleArn")]
pub service_access_role_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Endpoint {
#[serde(rename = "CertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
#[serde(rename = "DatabaseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database_name: Option<String>,
#[serde(rename = "DmsTransferSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dms_transfer_settings: Option<DmsTransferSettings>,
#[serde(rename = "DynamoDbSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamo_db_settings: Option<DynamoDbSettings>,
#[serde(rename = "EndpointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_arn: Option<String>,
#[serde(rename = "EndpointIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_identifier: Option<String>,
#[serde(rename = "EndpointType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_type: Option<String>,
#[serde(rename = "EngineDisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_display_name: Option<String>,
#[serde(rename = "EngineName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_name: Option<String>,
#[serde(rename = "ExternalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external_id: Option<String>,
#[serde(rename = "ExternalTableDefinition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external_table_definition: Option<String>,
#[serde(rename = "ExtraConnectionAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extra_connection_attributes: Option<String>,
#[serde(rename = "KmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "MongoDbSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mongo_db_settings: Option<MongoDbSettings>,
#[serde(rename = "Port")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port: Option<i64>,
#[serde(rename = "S3Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_settings: Option<S3Settings>,
#[serde(rename = "ServerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_name: Option<String>,
#[serde(rename = "ServiceAccessRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_access_role_arn: Option<String>,
#[serde(rename = "SslMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_mode: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Username")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Event {
#[serde(rename = "Date")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date: Option<f64>,
#[serde(rename = "EventCategories")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_categories: Option<Vec<String>>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "SourceIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_identifier: Option<String>,
#[serde(rename = "SourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct EventCategoryGroup {
#[serde(rename = "EventCategories")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_categories: Option<Vec<String>>,
#[serde(rename = "SourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct EventSubscription {
#[serde(rename = "CustSubscriptionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cust_subscription_id: Option<String>,
#[serde(rename = "CustomerAwsId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_aws_id: Option<String>,
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "EventCategoriesList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_categories_list: Option<Vec<String>>,
#[serde(rename = "SnsTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_topic_arn: Option<String>,
#[serde(rename = "SourceIdsList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_ids_list: Option<Vec<String>>,
#[serde(rename = "SourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_type: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "SubscriptionCreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_creation_time: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct Filter {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Values")]
pub values: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ImportCertificateMessage {
#[serde(rename = "CertificateIdentifier")]
pub certificate_identifier: String,
#[serde(rename = "CertificatePem")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_pem: Option<String>,
#[serde(rename = "CertificateWallet")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_wallet: Option<Vec<u8>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ImportCertificateResponse {
#[serde(rename = "Certificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate: Option<Certificate>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListTagsForResourceMessage {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "TagList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_list: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ModifyEndpointMessage {
#[serde(rename = "CertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
#[serde(rename = "DatabaseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database_name: Option<String>,
#[serde(rename = "DmsTransferSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dms_transfer_settings: Option<DmsTransferSettings>,
#[serde(rename = "DynamoDbSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamo_db_settings: Option<DynamoDbSettings>,
#[serde(rename = "EndpointArn")]
pub endpoint_arn: String,
#[serde(rename = "EndpointIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_identifier: Option<String>,
#[serde(rename = "EndpointType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_type: Option<String>,
#[serde(rename = "EngineName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_name: Option<String>,
#[serde(rename = "ExternalTableDefinition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external_table_definition: Option<String>,
#[serde(rename = "ExtraConnectionAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extra_connection_attributes: Option<String>,
#[serde(rename = "MongoDbSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mongo_db_settings: Option<MongoDbSettings>,
#[serde(rename = "Password")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password: Option<String>,
#[serde(rename = "Port")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port: Option<i64>,
#[serde(rename = "S3Settings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_settings: Option<S3Settings>,
#[serde(rename = "ServerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_name: Option<String>,
#[serde(rename = "ServiceAccessRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_access_role_arn: Option<String>,
#[serde(rename = "SslMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssl_mode: Option<String>,
#[serde(rename = "Username")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ModifyEndpointResponse {
#[serde(rename = "Endpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint: Option<Endpoint>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ModifyEventSubscriptionMessage {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "EventCategories")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_categories: Option<Vec<String>>,
#[serde(rename = "SnsTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_topic_arn: Option<String>,
#[serde(rename = "SourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_type: Option<String>,
#[serde(rename = "SubscriptionName")]
pub subscription_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ModifyEventSubscriptionResponse {
#[serde(rename = "EventSubscription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_subscription: Option<EventSubscription>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ModifyReplicationInstanceMessage {
#[serde(rename = "AllocatedStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allocated_storage: Option<i64>,
#[serde(rename = "AllowMajorVersionUpgrade")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_major_version_upgrade: Option<bool>,
#[serde(rename = "ApplyImmediately")]
#[serde(skip_serializing_if = "Option::is_none")]
pub apply_immediately: Option<bool>,
#[serde(rename = "AutoMinorVersionUpgrade")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_minor_version_upgrade: Option<bool>,
#[serde(rename = "EngineVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_version: Option<String>,
#[serde(rename = "MultiAZ")]
#[serde(skip_serializing_if = "Option::is_none")]
pub multi_az: Option<bool>,
#[serde(rename = "PreferredMaintenanceWindow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_maintenance_window: Option<String>,
#[serde(rename = "ReplicationInstanceArn")]
pub replication_instance_arn: String,
#[serde(rename = "ReplicationInstanceClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_class: Option<String>,
#[serde(rename = "ReplicationInstanceIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_identifier: Option<String>,
#[serde(rename = "VpcSecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_security_group_ids: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ModifyReplicationInstanceResponse {
#[serde(rename = "ReplicationInstance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance: Option<ReplicationInstance>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ModifyReplicationSubnetGroupMessage {
#[serde(rename = "ReplicationSubnetGroupDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_subnet_group_description: Option<String>,
#[serde(rename = "ReplicationSubnetGroupIdentifier")]
pub replication_subnet_group_identifier: String,
#[serde(rename = "SubnetIds")]
pub subnet_ids: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ModifyReplicationSubnetGroupResponse {
#[serde(rename = "ReplicationSubnetGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_subnet_group: Option<ReplicationSubnetGroup>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ModifyReplicationTaskMessage {
#[serde(rename = "CdcStartPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdc_start_position: Option<String>,
#[serde(rename = "CdcStartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdc_start_time: Option<f64>,
#[serde(rename = "CdcStopPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdc_stop_position: Option<String>,
#[serde(rename = "MigrationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub migration_type: Option<String>,
#[serde(rename = "ReplicationTaskArn")]
pub replication_task_arn: String,
#[serde(rename = "ReplicationTaskIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_identifier: Option<String>,
#[serde(rename = "ReplicationTaskSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_settings: Option<String>,
#[serde(rename = "TableMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_mappings: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ModifyReplicationTaskResponse {
#[serde(rename = "ReplicationTask")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task: Option<ReplicationTask>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MongoDbSettings {
#[serde(rename = "AuthMechanism")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_mechanism: Option<String>,
#[serde(rename = "AuthSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_source: Option<String>,
#[serde(rename = "AuthType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_type: Option<String>,
#[serde(rename = "DatabaseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database_name: Option<String>,
#[serde(rename = "DocsToInvestigate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub docs_to_investigate: Option<String>,
#[serde(rename = "ExtractDocId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extract_doc_id: Option<String>,
#[serde(rename = "KmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "NestingLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub nesting_level: Option<String>,
#[serde(rename = "Password")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password: Option<String>,
#[serde(rename = "Port")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port: Option<i64>,
#[serde(rename = "ServerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_name: Option<String>,
#[serde(rename = "Username")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct OrderableReplicationInstance {
#[serde(rename = "DefaultAllocatedStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_allocated_storage: Option<i64>,
#[serde(rename = "EngineVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_version: Option<String>,
#[serde(rename = "IncludedAllocatedStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub included_allocated_storage: Option<i64>,
#[serde(rename = "MaxAllocatedStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_allocated_storage: Option<i64>,
#[serde(rename = "MinAllocatedStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_allocated_storage: Option<i64>,
#[serde(rename = "ReplicationInstanceClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_class: Option<String>,
#[serde(rename = "StorageType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RebootReplicationInstanceMessage {
#[serde(rename = "ForceFailover")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force_failover: Option<bool>,
#[serde(rename = "ReplicationInstanceArn")]
pub replication_instance_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RebootReplicationInstanceResponse {
#[serde(rename = "ReplicationInstance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance: Option<ReplicationInstance>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RefreshSchemasMessage {
#[serde(rename = "EndpointArn")]
pub endpoint_arn: String,
#[serde(rename = "ReplicationInstanceArn")]
pub replication_instance_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RefreshSchemasResponse {
#[serde(rename = "RefreshSchemasStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub refresh_schemas_status: Option<RefreshSchemasStatus>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RefreshSchemasStatus {
#[serde(rename = "EndpointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_arn: Option<String>,
#[serde(rename = "LastFailureMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_failure_message: Option<String>,
#[serde(rename = "LastRefreshDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_refresh_date: Option<f64>,
#[serde(rename = "ReplicationInstanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_arn: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ReloadTablesMessage {
#[serde(rename = "ReloadOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reload_option: Option<String>,
#[serde(rename = "ReplicationTaskArn")]
pub replication_task_arn: String,
#[serde(rename = "TablesToReload")]
pub tables_to_reload: Vec<TableToReload>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ReloadTablesResponse {
#[serde(rename = "ReplicationTaskArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RemoveTagsFromResourceMessage {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RemoveTagsFromResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ReplicationInstance {
#[serde(rename = "AllocatedStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allocated_storage: Option<i64>,
#[serde(rename = "AutoMinorVersionUpgrade")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_minor_version_upgrade: Option<bool>,
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "EngineVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_version: Option<String>,
#[serde(rename = "FreeUntil")]
#[serde(skip_serializing_if = "Option::is_none")]
pub free_until: Option<f64>,
#[serde(rename = "InstanceCreateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_create_time: Option<f64>,
#[serde(rename = "KmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "MultiAZ")]
#[serde(skip_serializing_if = "Option::is_none")]
pub multi_az: Option<bool>,
#[serde(rename = "PendingModifiedValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pending_modified_values: Option<ReplicationPendingModifiedValues>,
#[serde(rename = "PreferredMaintenanceWindow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_maintenance_window: Option<String>,
#[serde(rename = "PubliclyAccessible")]
#[serde(skip_serializing_if = "Option::is_none")]
pub publicly_accessible: Option<bool>,
#[serde(rename = "ReplicationInstanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_arn: Option<String>,
#[serde(rename = "ReplicationInstanceClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_class: Option<String>,
#[serde(rename = "ReplicationInstanceIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_identifier: Option<String>,
#[serde(rename = "ReplicationInstancePrivateIpAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_private_ip_addresses: Option<Vec<String>>,
#[serde(rename = "ReplicationInstancePublicIpAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_public_ip_addresses: Option<Vec<String>>,
#[serde(rename = "ReplicationInstanceStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_status: Option<String>,
#[serde(rename = "ReplicationSubnetGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_subnet_group: Option<ReplicationSubnetGroup>,
#[serde(rename = "SecondaryAvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secondary_availability_zone: Option<String>,
#[serde(rename = "VpcSecurityGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_security_groups: Option<Vec<VpcSecurityGroupMembership>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ReplicationInstanceTaskLog {
#[serde(rename = "ReplicationInstanceTaskLogSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_task_log_size: Option<i64>,
#[serde(rename = "ReplicationTaskArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_arn: Option<String>,
#[serde(rename = "ReplicationTaskName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ReplicationPendingModifiedValues {
#[serde(rename = "AllocatedStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allocated_storage: Option<i64>,
#[serde(rename = "EngineVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_version: Option<String>,
#[serde(rename = "MultiAZ")]
#[serde(skip_serializing_if = "Option::is_none")]
pub multi_az: Option<bool>,
#[serde(rename = "ReplicationInstanceClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_class: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ReplicationSubnetGroup {
#[serde(rename = "ReplicationSubnetGroupDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_subnet_group_description: Option<String>,
#[serde(rename = "ReplicationSubnetGroupIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_subnet_group_identifier: Option<String>,
#[serde(rename = "SubnetGroupStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_group_status: Option<String>,
#[serde(rename = "Subnets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnets: Option<Vec<Subnet>>,
#[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 ReplicationTask {
#[serde(rename = "CdcStartPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdc_start_position: Option<String>,
#[serde(rename = "CdcStopPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdc_stop_position: Option<String>,
#[serde(rename = "LastFailureMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_failure_message: Option<String>,
#[serde(rename = "MigrationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub migration_type: Option<String>,
#[serde(rename = "RecoveryCheckpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_checkpoint: Option<String>,
#[serde(rename = "ReplicationInstanceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_instance_arn: Option<String>,
#[serde(rename = "ReplicationTaskArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_arn: Option<String>,
#[serde(rename = "ReplicationTaskCreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_creation_date: Option<f64>,
#[serde(rename = "ReplicationTaskIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_identifier: Option<String>,
#[serde(rename = "ReplicationTaskSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_settings: Option<String>,
#[serde(rename = "ReplicationTaskStartDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_start_date: Option<f64>,
#[serde(rename = "ReplicationTaskStats")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_stats: Option<ReplicationTaskStats>,
#[serde(rename = "SourceEndpointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_endpoint_arn: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StopReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stop_reason: Option<String>,
#[serde(rename = "TableMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_mappings: Option<String>,
#[serde(rename = "TargetEndpointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_endpoint_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ReplicationTaskAssessmentResult {
#[serde(rename = "AssessmentResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assessment_results: Option<String>,
#[serde(rename = "AssessmentResultsFile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assessment_results_file: Option<String>,
#[serde(rename = "AssessmentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assessment_status: Option<String>,
#[serde(rename = "ReplicationTaskArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_arn: Option<String>,
#[serde(rename = "ReplicationTaskIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_identifier: Option<String>,
#[serde(rename = "ReplicationTaskLastAssessmentDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task_last_assessment_date: Option<f64>,
#[serde(rename = "S3ObjectUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_object_url: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ReplicationTaskStats {
#[serde(rename = "ElapsedTimeMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elapsed_time_millis: Option<i64>,
#[serde(rename = "FullLoadProgressPercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub full_load_progress_percent: Option<i64>,
#[serde(rename = "TablesErrored")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tables_errored: Option<i64>,
#[serde(rename = "TablesLoaded")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tables_loaded: Option<i64>,
#[serde(rename = "TablesLoading")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tables_loading: Option<i64>,
#[serde(rename = "TablesQueued")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tables_queued: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct S3Settings {
#[serde(rename = "BucketFolder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket_folder: Option<String>,
#[serde(rename = "BucketName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket_name: Option<String>,
#[serde(rename = "CompressionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compression_type: Option<String>,
#[serde(rename = "CsvDelimiter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub csv_delimiter: Option<String>,
#[serde(rename = "CsvRowDelimiter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub csv_row_delimiter: Option<String>,
#[serde(rename = "ExternalTableDefinition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external_table_definition: Option<String>,
#[serde(rename = "ServiceAccessRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_access_role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartReplicationTaskAssessmentMessage {
#[serde(rename = "ReplicationTaskArn")]
pub replication_task_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StartReplicationTaskAssessmentResponse {
#[serde(rename = "ReplicationTask")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task: Option<ReplicationTask>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartReplicationTaskMessage {
#[serde(rename = "CdcStartPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdc_start_position: Option<String>,
#[serde(rename = "CdcStartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdc_start_time: Option<f64>,
#[serde(rename = "CdcStopPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdc_stop_position: Option<String>,
#[serde(rename = "ReplicationTaskArn")]
pub replication_task_arn: String,
#[serde(rename = "StartReplicationTaskType")]
pub start_replication_task_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StartReplicationTaskResponse {
#[serde(rename = "ReplicationTask")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task: Option<ReplicationTask>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StopReplicationTaskMessage {
#[serde(rename = "ReplicationTaskArn")]
pub replication_task_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StopReplicationTaskResponse {
#[serde(rename = "ReplicationTask")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_task: Option<ReplicationTask>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Subnet {
#[serde(rename = "SubnetAvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_availability_zone: Option<AvailabilityZone>,
#[serde(rename = "SubnetIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_identifier: Option<String>,
#[serde(rename = "SubnetStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct SupportedEndpointType {
#[serde(rename = "EndpointType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_type: Option<String>,
#[serde(rename = "EngineDisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_display_name: Option<String>,
#[serde(rename = "EngineName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub engine_name: Option<String>,
#[serde(rename = "SupportsCDC")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supports_cdc: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct TableStatistics {
#[serde(rename = "Ddls")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ddls: Option<i64>,
#[serde(rename = "Deletes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deletes: Option<i64>,
#[serde(rename = "FullLoadCondtnlChkFailedRows")]
#[serde(skip_serializing_if = "Option::is_none")]
pub full_load_condtnl_chk_failed_rows: Option<i64>,
#[serde(rename = "FullLoadErrorRows")]
#[serde(skip_serializing_if = "Option::is_none")]
pub full_load_error_rows: Option<i64>,
#[serde(rename = "FullLoadRows")]
#[serde(skip_serializing_if = "Option::is_none")]
pub full_load_rows: Option<i64>,
#[serde(rename = "Inserts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inserts: Option<i64>,
#[serde(rename = "LastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "SchemaName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_name: Option<String>,
#[serde(rename = "TableName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_name: Option<String>,
#[serde(rename = "TableState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_state: Option<String>,
#[serde(rename = "Updates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updates: Option<i64>,
#[serde(rename = "ValidationFailedRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_failed_records: Option<i64>,
#[serde(rename = "ValidationPendingRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_pending_records: Option<i64>,
#[serde(rename = "ValidationState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_state: Option<String>,
#[serde(rename = "ValidationStateDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_state_details: Option<String>,
#[serde(rename = "ValidationSuspendedRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_suspended_records: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct TableToReload {
#[serde(rename = "SchemaName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_name: Option<String>,
#[serde(rename = "TableName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Tag {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct TestConnectionMessage {
#[serde(rename = "EndpointArn")]
pub endpoint_arn: String,
#[serde(rename = "ReplicationInstanceArn")]
pub replication_instance_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct TestConnectionResponse {
#[serde(rename = "Connection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection: Option<Connection>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct VpcSecurityGroupMembership {
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "VpcSecurityGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_security_group_id: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AddTagsToResourceError {
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AddTagsToResourceError {
pub fn from_response(res: BufferedHttpResponse) -> AddTagsToResourceError {
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 {
"ResourceNotFoundFault" => {
return AddTagsToResourceError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return AddTagsToResourceError::Validation(error_message.to_string())
}
_ => {}
}
}
return AddTagsToResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AddTagsToResourceError {
fn from(err: serde_json::error::Error) -> AddTagsToResourceError {
AddTagsToResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AddTagsToResourceError {
fn from(err: CredentialsError) -> AddTagsToResourceError {
AddTagsToResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for AddTagsToResourceError {
fn from(err: HttpDispatchError) -> AddTagsToResourceError {
AddTagsToResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for AddTagsToResourceError {
fn from(err: io::Error) -> AddTagsToResourceError {
AddTagsToResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AddTagsToResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AddTagsToResourceError {
fn description(&self) -> &str {
match *self {
AddTagsToResourceError::ResourceNotFoundFault(ref cause) => cause,
AddTagsToResourceError::Validation(ref cause) => cause,
AddTagsToResourceError::Credentials(ref err) => err.description(),
AddTagsToResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AddTagsToResourceError::ParseError(ref cause) => cause,
AddTagsToResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateEndpointError {
AccessDeniedFault(String),
InvalidResourceStateFault(String),
KMSKeyNotAccessibleFault(String),
ResourceAlreadyExistsFault(String),
ResourceNotFoundFault(String),
ResourceQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> CreateEndpointError {
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 {
"AccessDeniedFault" => {
return CreateEndpointError::AccessDeniedFault(String::from(error_message))
}
"InvalidResourceStateFault" => {
return CreateEndpointError::InvalidResourceStateFault(String::from(
error_message,
))
}
"KMSKeyNotAccessibleFault" => {
return CreateEndpointError::KMSKeyNotAccessibleFault(String::from(
error_message,
))
}
"ResourceAlreadyExistsFault" => {
return CreateEndpointError::ResourceAlreadyExistsFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return CreateEndpointError::ResourceNotFoundFault(String::from(error_message))
}
"ResourceQuotaExceededFault" => {
return CreateEndpointError::ResourceQuotaExceededFault(String::from(
error_message,
))
}
"ValidationException" => {
return CreateEndpointError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateEndpointError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateEndpointError {
fn from(err: serde_json::error::Error) -> CreateEndpointError {
CreateEndpointError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateEndpointError {
fn from(err: CredentialsError) -> CreateEndpointError {
CreateEndpointError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateEndpointError {
fn from(err: HttpDispatchError) -> CreateEndpointError {
CreateEndpointError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateEndpointError {
fn from(err: io::Error) -> CreateEndpointError {
CreateEndpointError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateEndpointError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateEndpointError {
fn description(&self) -> &str {
match *self {
CreateEndpointError::AccessDeniedFault(ref cause) => cause,
CreateEndpointError::InvalidResourceStateFault(ref cause) => cause,
CreateEndpointError::KMSKeyNotAccessibleFault(ref cause) => cause,
CreateEndpointError::ResourceAlreadyExistsFault(ref cause) => cause,
CreateEndpointError::ResourceNotFoundFault(ref cause) => cause,
CreateEndpointError::ResourceQuotaExceededFault(ref cause) => cause,
CreateEndpointError::Validation(ref cause) => cause,
CreateEndpointError::Credentials(ref err) => err.description(),
CreateEndpointError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateEndpointError::ParseError(ref cause) => cause,
CreateEndpointError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateEventSubscriptionError {
ResourceAlreadyExistsFault(String),
ResourceNotFoundFault(String),
ResourceQuotaExceededFault(String),
SNSInvalidTopicFault(String),
SNSNoAuthorizationFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateEventSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateEventSubscriptionError {
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 {
"ResourceAlreadyExistsFault" => {
return CreateEventSubscriptionError::ResourceAlreadyExistsFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return CreateEventSubscriptionError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ResourceQuotaExceededFault" => {
return CreateEventSubscriptionError::ResourceQuotaExceededFault(String::from(
error_message,
))
}
"SNSInvalidTopicFault" => {
return CreateEventSubscriptionError::SNSInvalidTopicFault(String::from(
error_message,
))
}
"SNSNoAuthorizationFault" => {
return CreateEventSubscriptionError::SNSNoAuthorizationFault(String::from(
error_message,
))
}
"ValidationException" => {
return CreateEventSubscriptionError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateEventSubscriptionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateEventSubscriptionError {
fn from(err: serde_json::error::Error) -> CreateEventSubscriptionError {
CreateEventSubscriptionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateEventSubscriptionError {
fn from(err: CredentialsError) -> CreateEventSubscriptionError {
CreateEventSubscriptionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateEventSubscriptionError {
fn from(err: HttpDispatchError) -> CreateEventSubscriptionError {
CreateEventSubscriptionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateEventSubscriptionError {
fn from(err: io::Error) -> CreateEventSubscriptionError {
CreateEventSubscriptionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateEventSubscriptionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateEventSubscriptionError {
fn description(&self) -> &str {
match *self {
CreateEventSubscriptionError::ResourceAlreadyExistsFault(ref cause) => cause,
CreateEventSubscriptionError::ResourceNotFoundFault(ref cause) => cause,
CreateEventSubscriptionError::ResourceQuotaExceededFault(ref cause) => cause,
CreateEventSubscriptionError::SNSInvalidTopicFault(ref cause) => cause,
CreateEventSubscriptionError::SNSNoAuthorizationFault(ref cause) => cause,
CreateEventSubscriptionError::Validation(ref cause) => cause,
CreateEventSubscriptionError::Credentials(ref err) => err.description(),
CreateEventSubscriptionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateEventSubscriptionError::ParseError(ref cause) => cause,
CreateEventSubscriptionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateReplicationInstanceError {
AccessDeniedFault(String),
InsufficientResourceCapacityFault(String),
InvalidResourceStateFault(String),
InvalidSubnet(String),
KMSKeyNotAccessibleFault(String),
ReplicationSubnetGroupDoesNotCoverEnoughAZs(String),
ResourceAlreadyExistsFault(String),
ResourceNotFoundFault(String),
ResourceQuotaExceededFault(String),
StorageQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateReplicationInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> CreateReplicationInstanceError {
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 {
"AccessDeniedFault" => return CreateReplicationInstanceError::AccessDeniedFault(String::from(error_message)),
"InsufficientResourceCapacityFault" => return CreateReplicationInstanceError::InsufficientResourceCapacityFault(String::from(error_message)),
"InvalidResourceStateFault" => return CreateReplicationInstanceError::InvalidResourceStateFault(String::from(error_message)),
"InvalidSubnet" => return CreateReplicationInstanceError::InvalidSubnet(String::from(error_message)),
"KMSKeyNotAccessibleFault" => return CreateReplicationInstanceError::KMSKeyNotAccessibleFault(String::from(error_message)),
"ReplicationSubnetGroupDoesNotCoverEnoughAZs" => return CreateReplicationInstanceError::ReplicationSubnetGroupDoesNotCoverEnoughAZs(String::from(error_message)),
"ResourceAlreadyExistsFault" => return CreateReplicationInstanceError::ResourceAlreadyExistsFault(String::from(error_message)),
"ResourceNotFoundFault" => return CreateReplicationInstanceError::ResourceNotFoundFault(String::from(error_message)),
"ResourceQuotaExceededFault" => return CreateReplicationInstanceError::ResourceQuotaExceededFault(String::from(error_message)),
"StorageQuotaExceededFault" => return CreateReplicationInstanceError::StorageQuotaExceededFault(String::from(error_message)),
"ValidationException" => return CreateReplicationInstanceError::Validation(error_message.to_string()),
_ => {}
}
}
return CreateReplicationInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateReplicationInstanceError {
fn from(err: serde_json::error::Error) -> CreateReplicationInstanceError {
CreateReplicationInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateReplicationInstanceError {
fn from(err: CredentialsError) -> CreateReplicationInstanceError {
CreateReplicationInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateReplicationInstanceError {
fn from(err: HttpDispatchError) -> CreateReplicationInstanceError {
CreateReplicationInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateReplicationInstanceError {
fn from(err: io::Error) -> CreateReplicationInstanceError {
CreateReplicationInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateReplicationInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateReplicationInstanceError {
fn description(&self) -> &str {
match *self {
CreateReplicationInstanceError::AccessDeniedFault(ref cause) => cause,
CreateReplicationInstanceError::InsufficientResourceCapacityFault(ref cause) => cause,
CreateReplicationInstanceError::InvalidResourceStateFault(ref cause) => cause,
CreateReplicationInstanceError::InvalidSubnet(ref cause) => cause,
CreateReplicationInstanceError::KMSKeyNotAccessibleFault(ref cause) => cause,
CreateReplicationInstanceError::ReplicationSubnetGroupDoesNotCoverEnoughAZs(
ref cause,
) => cause,
CreateReplicationInstanceError::ResourceAlreadyExistsFault(ref cause) => cause,
CreateReplicationInstanceError::ResourceNotFoundFault(ref cause) => cause,
CreateReplicationInstanceError::ResourceQuotaExceededFault(ref cause) => cause,
CreateReplicationInstanceError::StorageQuotaExceededFault(ref cause) => cause,
CreateReplicationInstanceError::Validation(ref cause) => cause,
CreateReplicationInstanceError::Credentials(ref err) => err.description(),
CreateReplicationInstanceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateReplicationInstanceError::ParseError(ref cause) => cause,
CreateReplicationInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateReplicationSubnetGroupError {
AccessDeniedFault(String),
InvalidSubnet(String),
ReplicationSubnetGroupDoesNotCoverEnoughAZs(String),
ResourceAlreadyExistsFault(String),
ResourceNotFoundFault(String),
ResourceQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateReplicationSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> CreateReplicationSubnetGroupError {
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 {
"AccessDeniedFault" => return CreateReplicationSubnetGroupError::AccessDeniedFault(String::from(error_message)),
"InvalidSubnet" => return CreateReplicationSubnetGroupError::InvalidSubnet(String::from(error_message)),
"ReplicationSubnetGroupDoesNotCoverEnoughAZs" => return CreateReplicationSubnetGroupError::ReplicationSubnetGroupDoesNotCoverEnoughAZs(String::from(error_message)),
"ResourceAlreadyExistsFault" => return CreateReplicationSubnetGroupError::ResourceAlreadyExistsFault(String::from(error_message)),
"ResourceNotFoundFault" => return CreateReplicationSubnetGroupError::ResourceNotFoundFault(String::from(error_message)),
"ResourceQuotaExceededFault" => return CreateReplicationSubnetGroupError::ResourceQuotaExceededFault(String::from(error_message)),
"ValidationException" => return CreateReplicationSubnetGroupError::Validation(error_message.to_string()),
_ => {}
}
}
return CreateReplicationSubnetGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateReplicationSubnetGroupError {
fn from(err: serde_json::error::Error) -> CreateReplicationSubnetGroupError {
CreateReplicationSubnetGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateReplicationSubnetGroupError {
fn from(err: CredentialsError) -> CreateReplicationSubnetGroupError {
CreateReplicationSubnetGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateReplicationSubnetGroupError {
fn from(err: HttpDispatchError) -> CreateReplicationSubnetGroupError {
CreateReplicationSubnetGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateReplicationSubnetGroupError {
fn from(err: io::Error) -> CreateReplicationSubnetGroupError {
CreateReplicationSubnetGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateReplicationSubnetGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateReplicationSubnetGroupError {
fn description(&self) -> &str {
match *self {
CreateReplicationSubnetGroupError::AccessDeniedFault(ref cause) => cause,
CreateReplicationSubnetGroupError::InvalidSubnet(ref cause) => cause,
CreateReplicationSubnetGroupError::ReplicationSubnetGroupDoesNotCoverEnoughAZs(
ref cause,
) => cause,
CreateReplicationSubnetGroupError::ResourceAlreadyExistsFault(ref cause) => cause,
CreateReplicationSubnetGroupError::ResourceNotFoundFault(ref cause) => cause,
CreateReplicationSubnetGroupError::ResourceQuotaExceededFault(ref cause) => cause,
CreateReplicationSubnetGroupError::Validation(ref cause) => cause,
CreateReplicationSubnetGroupError::Credentials(ref err) => err.description(),
CreateReplicationSubnetGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateReplicationSubnetGroupError::ParseError(ref cause) => cause,
CreateReplicationSubnetGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateReplicationTaskError {
AccessDeniedFault(String),
InvalidResourceStateFault(String),
KMSKeyNotAccessibleFault(String),
ResourceAlreadyExistsFault(String),
ResourceNotFoundFault(String),
ResourceQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateReplicationTaskError {
pub fn from_response(res: BufferedHttpResponse) -> CreateReplicationTaskError {
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 {
"AccessDeniedFault" => {
return CreateReplicationTaskError::AccessDeniedFault(String::from(
error_message,
))
}
"InvalidResourceStateFault" => {
return CreateReplicationTaskError::InvalidResourceStateFault(String::from(
error_message,
))
}
"KMSKeyNotAccessibleFault" => {
return CreateReplicationTaskError::KMSKeyNotAccessibleFault(String::from(
error_message,
))
}
"ResourceAlreadyExistsFault" => {
return CreateReplicationTaskError::ResourceAlreadyExistsFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return CreateReplicationTaskError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ResourceQuotaExceededFault" => {
return CreateReplicationTaskError::ResourceQuotaExceededFault(String::from(
error_message,
))
}
"ValidationException" => {
return CreateReplicationTaskError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateReplicationTaskError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateReplicationTaskError {
fn from(err: serde_json::error::Error) -> CreateReplicationTaskError {
CreateReplicationTaskError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateReplicationTaskError {
fn from(err: CredentialsError) -> CreateReplicationTaskError {
CreateReplicationTaskError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateReplicationTaskError {
fn from(err: HttpDispatchError) -> CreateReplicationTaskError {
CreateReplicationTaskError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateReplicationTaskError {
fn from(err: io::Error) -> CreateReplicationTaskError {
CreateReplicationTaskError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateReplicationTaskError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateReplicationTaskError {
fn description(&self) -> &str {
match *self {
CreateReplicationTaskError::AccessDeniedFault(ref cause) => cause,
CreateReplicationTaskError::InvalidResourceStateFault(ref cause) => cause,
CreateReplicationTaskError::KMSKeyNotAccessibleFault(ref cause) => cause,
CreateReplicationTaskError::ResourceAlreadyExistsFault(ref cause) => cause,
CreateReplicationTaskError::ResourceNotFoundFault(ref cause) => cause,
CreateReplicationTaskError::ResourceQuotaExceededFault(ref cause) => cause,
CreateReplicationTaskError::Validation(ref cause) => cause,
CreateReplicationTaskError::Credentials(ref err) => err.description(),
CreateReplicationTaskError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateReplicationTaskError::ParseError(ref cause) => cause,
CreateReplicationTaskError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteCertificateError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteCertificateError {
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 {
"InvalidResourceStateFault" => {
return DeleteCertificateError::InvalidResourceStateFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return DeleteCertificateError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return DeleteCertificateError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteCertificateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteCertificateError {
fn from(err: serde_json::error::Error) -> DeleteCertificateError {
DeleteCertificateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteCertificateError {
fn from(err: CredentialsError) -> DeleteCertificateError {
DeleteCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteCertificateError {
fn from(err: HttpDispatchError) -> DeleteCertificateError {
DeleteCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteCertificateError {
fn from(err: io::Error) -> DeleteCertificateError {
DeleteCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteCertificateError {
fn description(&self) -> &str {
match *self {
DeleteCertificateError::InvalidResourceStateFault(ref cause) => cause,
DeleteCertificateError::ResourceNotFoundFault(ref cause) => cause,
DeleteCertificateError::Validation(ref cause) => cause,
DeleteCertificateError::Credentials(ref err) => err.description(),
DeleteCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteCertificateError::ParseError(ref cause) => cause,
DeleteCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteEndpointError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteEndpointError {
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 {
"InvalidResourceStateFault" => {
return DeleteEndpointError::InvalidResourceStateFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return DeleteEndpointError::ResourceNotFoundFault(String::from(error_message))
}
"ValidationException" => {
return DeleteEndpointError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteEndpointError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteEndpointError {
fn from(err: serde_json::error::Error) -> DeleteEndpointError {
DeleteEndpointError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteEndpointError {
fn from(err: CredentialsError) -> DeleteEndpointError {
DeleteEndpointError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteEndpointError {
fn from(err: HttpDispatchError) -> DeleteEndpointError {
DeleteEndpointError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteEndpointError {
fn from(err: io::Error) -> DeleteEndpointError {
DeleteEndpointError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteEndpointError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteEndpointError {
fn description(&self) -> &str {
match *self {
DeleteEndpointError::InvalidResourceStateFault(ref cause) => cause,
DeleteEndpointError::ResourceNotFoundFault(ref cause) => cause,
DeleteEndpointError::Validation(ref cause) => cause,
DeleteEndpointError::Credentials(ref err) => err.description(),
DeleteEndpointError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteEndpointError::ParseError(ref cause) => cause,
DeleteEndpointError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteEventSubscriptionError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteEventSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteEventSubscriptionError {
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 {
"InvalidResourceStateFault" => {
return DeleteEventSubscriptionError::InvalidResourceStateFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return DeleteEventSubscriptionError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return DeleteEventSubscriptionError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteEventSubscriptionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteEventSubscriptionError {
fn from(err: serde_json::error::Error) -> DeleteEventSubscriptionError {
DeleteEventSubscriptionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteEventSubscriptionError {
fn from(err: CredentialsError) -> DeleteEventSubscriptionError {
DeleteEventSubscriptionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteEventSubscriptionError {
fn from(err: HttpDispatchError) -> DeleteEventSubscriptionError {
DeleteEventSubscriptionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteEventSubscriptionError {
fn from(err: io::Error) -> DeleteEventSubscriptionError {
DeleteEventSubscriptionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteEventSubscriptionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteEventSubscriptionError {
fn description(&self) -> &str {
match *self {
DeleteEventSubscriptionError::InvalidResourceStateFault(ref cause) => cause,
DeleteEventSubscriptionError::ResourceNotFoundFault(ref cause) => cause,
DeleteEventSubscriptionError::Validation(ref cause) => cause,
DeleteEventSubscriptionError::Credentials(ref err) => err.description(),
DeleteEventSubscriptionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteEventSubscriptionError::ParseError(ref cause) => cause,
DeleteEventSubscriptionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteReplicationInstanceError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteReplicationInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteReplicationInstanceError {
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 {
"InvalidResourceStateFault" => {
return DeleteReplicationInstanceError::InvalidResourceStateFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return DeleteReplicationInstanceError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return DeleteReplicationInstanceError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteReplicationInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteReplicationInstanceError {
fn from(err: serde_json::error::Error) -> DeleteReplicationInstanceError {
DeleteReplicationInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteReplicationInstanceError {
fn from(err: CredentialsError) -> DeleteReplicationInstanceError {
DeleteReplicationInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteReplicationInstanceError {
fn from(err: HttpDispatchError) -> DeleteReplicationInstanceError {
DeleteReplicationInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteReplicationInstanceError {
fn from(err: io::Error) -> DeleteReplicationInstanceError {
DeleteReplicationInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteReplicationInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteReplicationInstanceError {
fn description(&self) -> &str {
match *self {
DeleteReplicationInstanceError::InvalidResourceStateFault(ref cause) => cause,
DeleteReplicationInstanceError::ResourceNotFoundFault(ref cause) => cause,
DeleteReplicationInstanceError::Validation(ref cause) => cause,
DeleteReplicationInstanceError::Credentials(ref err) => err.description(),
DeleteReplicationInstanceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteReplicationInstanceError::ParseError(ref cause) => cause,
DeleteReplicationInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteReplicationSubnetGroupError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteReplicationSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteReplicationSubnetGroupError {
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 {
"InvalidResourceStateFault" => {
return DeleteReplicationSubnetGroupError::InvalidResourceStateFault(
String::from(error_message),
)
}
"ResourceNotFoundFault" => {
return DeleteReplicationSubnetGroupError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return DeleteReplicationSubnetGroupError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteReplicationSubnetGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteReplicationSubnetGroupError {
fn from(err: serde_json::error::Error) -> DeleteReplicationSubnetGroupError {
DeleteReplicationSubnetGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteReplicationSubnetGroupError {
fn from(err: CredentialsError) -> DeleteReplicationSubnetGroupError {
DeleteReplicationSubnetGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteReplicationSubnetGroupError {
fn from(err: HttpDispatchError) -> DeleteReplicationSubnetGroupError {
DeleteReplicationSubnetGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteReplicationSubnetGroupError {
fn from(err: io::Error) -> DeleteReplicationSubnetGroupError {
DeleteReplicationSubnetGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteReplicationSubnetGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteReplicationSubnetGroupError {
fn description(&self) -> &str {
match *self {
DeleteReplicationSubnetGroupError::InvalidResourceStateFault(ref cause) => cause,
DeleteReplicationSubnetGroupError::ResourceNotFoundFault(ref cause) => cause,
DeleteReplicationSubnetGroupError::Validation(ref cause) => cause,
DeleteReplicationSubnetGroupError::Credentials(ref err) => err.description(),
DeleteReplicationSubnetGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteReplicationSubnetGroupError::ParseError(ref cause) => cause,
DeleteReplicationSubnetGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteReplicationTaskError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteReplicationTaskError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteReplicationTaskError {
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 {
"InvalidResourceStateFault" => {
return DeleteReplicationTaskError::InvalidResourceStateFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return DeleteReplicationTaskError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return DeleteReplicationTaskError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteReplicationTaskError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteReplicationTaskError {
fn from(err: serde_json::error::Error) -> DeleteReplicationTaskError {
DeleteReplicationTaskError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteReplicationTaskError {
fn from(err: CredentialsError) -> DeleteReplicationTaskError {
DeleteReplicationTaskError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteReplicationTaskError {
fn from(err: HttpDispatchError) -> DeleteReplicationTaskError {
DeleteReplicationTaskError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteReplicationTaskError {
fn from(err: io::Error) -> DeleteReplicationTaskError {
DeleteReplicationTaskError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteReplicationTaskError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteReplicationTaskError {
fn description(&self) -> &str {
match *self {
DeleteReplicationTaskError::InvalidResourceStateFault(ref cause) => cause,
DeleteReplicationTaskError::ResourceNotFoundFault(ref cause) => cause,
DeleteReplicationTaskError::Validation(ref cause) => cause,
DeleteReplicationTaskError::Credentials(ref err) => err.description(),
DeleteReplicationTaskError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteReplicationTaskError::ParseError(ref cause) => cause,
DeleteReplicationTaskError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAccountAttributesError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAccountAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAccountAttributesError {
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 DescribeAccountAttributesError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeAccountAttributesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeAccountAttributesError {
fn from(err: serde_json::error::Error) -> DescribeAccountAttributesError {
DescribeAccountAttributesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeAccountAttributesError {
fn from(err: CredentialsError) -> DescribeAccountAttributesError {
DescribeAccountAttributesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAccountAttributesError {
fn from(err: HttpDispatchError) -> DescribeAccountAttributesError {
DescribeAccountAttributesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAccountAttributesError {
fn from(err: io::Error) -> DescribeAccountAttributesError {
DescribeAccountAttributesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAccountAttributesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAccountAttributesError {
fn description(&self) -> &str {
match *self {
DescribeAccountAttributesError::Validation(ref cause) => cause,
DescribeAccountAttributesError::Credentials(ref err) => err.description(),
DescribeAccountAttributesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAccountAttributesError::ParseError(ref cause) => cause,
DescribeAccountAttributesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeCertificatesError {
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeCertificatesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeCertificatesError {
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 {
"ResourceNotFoundFault" => {
return DescribeCertificatesError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return DescribeCertificatesError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeCertificatesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeCertificatesError {
fn from(err: serde_json::error::Error) -> DescribeCertificatesError {
DescribeCertificatesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeCertificatesError {
fn from(err: CredentialsError) -> DescribeCertificatesError {
DescribeCertificatesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeCertificatesError {
fn from(err: HttpDispatchError) -> DescribeCertificatesError {
DescribeCertificatesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeCertificatesError {
fn from(err: io::Error) -> DescribeCertificatesError {
DescribeCertificatesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeCertificatesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeCertificatesError {
fn description(&self) -> &str {
match *self {
DescribeCertificatesError::ResourceNotFoundFault(ref cause) => cause,
DescribeCertificatesError::Validation(ref cause) => cause,
DescribeCertificatesError::Credentials(ref err) => err.description(),
DescribeCertificatesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeCertificatesError::ParseError(ref cause) => cause,
DescribeCertificatesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeConnectionsError {
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeConnectionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeConnectionsError {
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 {
"ResourceNotFoundFault" => {
return DescribeConnectionsError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return DescribeConnectionsError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeConnectionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeConnectionsError {
fn from(err: serde_json::error::Error) -> DescribeConnectionsError {
DescribeConnectionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeConnectionsError {
fn from(err: CredentialsError) -> DescribeConnectionsError {
DescribeConnectionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeConnectionsError {
fn from(err: HttpDispatchError) -> DescribeConnectionsError {
DescribeConnectionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeConnectionsError {
fn from(err: io::Error) -> DescribeConnectionsError {
DescribeConnectionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeConnectionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeConnectionsError {
fn description(&self) -> &str {
match *self {
DescribeConnectionsError::ResourceNotFoundFault(ref cause) => cause,
DescribeConnectionsError::Validation(ref cause) => cause,
DescribeConnectionsError::Credentials(ref err) => err.description(),
DescribeConnectionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeConnectionsError::ParseError(ref cause) => cause,
DescribeConnectionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeEndpointTypesError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeEndpointTypesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeEndpointTypesError {
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 DescribeEndpointTypesError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeEndpointTypesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeEndpointTypesError {
fn from(err: serde_json::error::Error) -> DescribeEndpointTypesError {
DescribeEndpointTypesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeEndpointTypesError {
fn from(err: CredentialsError) -> DescribeEndpointTypesError {
DescribeEndpointTypesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeEndpointTypesError {
fn from(err: HttpDispatchError) -> DescribeEndpointTypesError {
DescribeEndpointTypesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeEndpointTypesError {
fn from(err: io::Error) -> DescribeEndpointTypesError {
DescribeEndpointTypesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeEndpointTypesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeEndpointTypesError {
fn description(&self) -> &str {
match *self {
DescribeEndpointTypesError::Validation(ref cause) => cause,
DescribeEndpointTypesError::Credentials(ref err) => err.description(),
DescribeEndpointTypesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeEndpointTypesError::ParseError(ref cause) => cause,
DescribeEndpointTypesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeEndpointsError {
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeEndpointsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeEndpointsError {
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 {
"ResourceNotFoundFault" => {
return DescribeEndpointsError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return DescribeEndpointsError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeEndpointsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeEndpointsError {
fn from(err: serde_json::error::Error) -> DescribeEndpointsError {
DescribeEndpointsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeEndpointsError {
fn from(err: CredentialsError) -> DescribeEndpointsError {
DescribeEndpointsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeEndpointsError {
fn from(err: HttpDispatchError) -> DescribeEndpointsError {
DescribeEndpointsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeEndpointsError {
fn from(err: io::Error) -> DescribeEndpointsError {
DescribeEndpointsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeEndpointsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeEndpointsError {
fn description(&self) -> &str {
match *self {
DescribeEndpointsError::ResourceNotFoundFault(ref cause) => cause,
DescribeEndpointsError::Validation(ref cause) => cause,
DescribeEndpointsError::Credentials(ref err) => err.description(),
DescribeEndpointsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeEndpointsError::ParseError(ref cause) => cause,
DescribeEndpointsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeEventCategoriesError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeEventCategoriesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeEventCategoriesError {
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 DescribeEventCategoriesError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeEventCategoriesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeEventCategoriesError {
fn from(err: serde_json::error::Error) -> DescribeEventCategoriesError {
DescribeEventCategoriesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeEventCategoriesError {
fn from(err: CredentialsError) -> DescribeEventCategoriesError {
DescribeEventCategoriesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeEventCategoriesError {
fn from(err: HttpDispatchError) -> DescribeEventCategoriesError {
DescribeEventCategoriesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeEventCategoriesError {
fn from(err: io::Error) -> DescribeEventCategoriesError {
DescribeEventCategoriesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeEventCategoriesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeEventCategoriesError {
fn description(&self) -> &str {
match *self {
DescribeEventCategoriesError::Validation(ref cause) => cause,
DescribeEventCategoriesError::Credentials(ref err) => err.description(),
DescribeEventCategoriesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeEventCategoriesError::ParseError(ref cause) => cause,
DescribeEventCategoriesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeEventSubscriptionsError {
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeEventSubscriptionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeEventSubscriptionsError {
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 {
"ResourceNotFoundFault" => {
return DescribeEventSubscriptionsError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return DescribeEventSubscriptionsError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeEventSubscriptionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeEventSubscriptionsError {
fn from(err: serde_json::error::Error) -> DescribeEventSubscriptionsError {
DescribeEventSubscriptionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeEventSubscriptionsError {
fn from(err: CredentialsError) -> DescribeEventSubscriptionsError {
DescribeEventSubscriptionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeEventSubscriptionsError {
fn from(err: HttpDispatchError) -> DescribeEventSubscriptionsError {
DescribeEventSubscriptionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeEventSubscriptionsError {
fn from(err: io::Error) -> DescribeEventSubscriptionsError {
DescribeEventSubscriptionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeEventSubscriptionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeEventSubscriptionsError {
fn description(&self) -> &str {
match *self {
DescribeEventSubscriptionsError::ResourceNotFoundFault(ref cause) => cause,
DescribeEventSubscriptionsError::Validation(ref cause) => cause,
DescribeEventSubscriptionsError::Credentials(ref err) => err.description(),
DescribeEventSubscriptionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeEventSubscriptionsError::ParseError(ref cause) => cause,
DescribeEventSubscriptionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeEventsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeEventsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeEventsError {
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 DescribeEventsError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeEventsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeEventsError {
fn from(err: serde_json::error::Error) -> DescribeEventsError {
DescribeEventsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeEventsError {
fn from(err: CredentialsError) -> DescribeEventsError {
DescribeEventsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeEventsError {
fn from(err: HttpDispatchError) -> DescribeEventsError {
DescribeEventsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeEventsError {
fn from(err: io::Error) -> DescribeEventsError {
DescribeEventsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeEventsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeEventsError {
fn description(&self) -> &str {
match *self {
DescribeEventsError::Validation(ref cause) => cause,
DescribeEventsError::Credentials(ref err) => err.description(),
DescribeEventsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeEventsError::ParseError(ref cause) => cause,
DescribeEventsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeOrderableReplicationInstancesError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeOrderableReplicationInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeOrderableReplicationInstancesError {
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 DescribeOrderableReplicationInstancesError::Validation(
error_message.to_string(),
)
}
_ => {}
}
}
return DescribeOrderableReplicationInstancesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeOrderableReplicationInstancesError {
fn from(err: serde_json::error::Error) -> DescribeOrderableReplicationInstancesError {
DescribeOrderableReplicationInstancesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeOrderableReplicationInstancesError {
fn from(err: CredentialsError) -> DescribeOrderableReplicationInstancesError {
DescribeOrderableReplicationInstancesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeOrderableReplicationInstancesError {
fn from(err: HttpDispatchError) -> DescribeOrderableReplicationInstancesError {
DescribeOrderableReplicationInstancesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeOrderableReplicationInstancesError {
fn from(err: io::Error) -> DescribeOrderableReplicationInstancesError {
DescribeOrderableReplicationInstancesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeOrderableReplicationInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeOrderableReplicationInstancesError {
fn description(&self) -> &str {
match *self {
DescribeOrderableReplicationInstancesError::Validation(ref cause) => cause,
DescribeOrderableReplicationInstancesError::Credentials(ref err) => err.description(),
DescribeOrderableReplicationInstancesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeOrderableReplicationInstancesError::ParseError(ref cause) => cause,
DescribeOrderableReplicationInstancesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeRefreshSchemasStatusError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeRefreshSchemasStatusError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeRefreshSchemasStatusError {
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 {
"InvalidResourceStateFault" => {
return DescribeRefreshSchemasStatusError::InvalidResourceStateFault(
String::from(error_message),
)
}
"ResourceNotFoundFault" => {
return DescribeRefreshSchemasStatusError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return DescribeRefreshSchemasStatusError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeRefreshSchemasStatusError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeRefreshSchemasStatusError {
fn from(err: serde_json::error::Error) -> DescribeRefreshSchemasStatusError {
DescribeRefreshSchemasStatusError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeRefreshSchemasStatusError {
fn from(err: CredentialsError) -> DescribeRefreshSchemasStatusError {
DescribeRefreshSchemasStatusError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeRefreshSchemasStatusError {
fn from(err: HttpDispatchError) -> DescribeRefreshSchemasStatusError {
DescribeRefreshSchemasStatusError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeRefreshSchemasStatusError {
fn from(err: io::Error) -> DescribeRefreshSchemasStatusError {
DescribeRefreshSchemasStatusError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeRefreshSchemasStatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeRefreshSchemasStatusError {
fn description(&self) -> &str {
match *self {
DescribeRefreshSchemasStatusError::InvalidResourceStateFault(ref cause) => cause,
DescribeRefreshSchemasStatusError::ResourceNotFoundFault(ref cause) => cause,
DescribeRefreshSchemasStatusError::Validation(ref cause) => cause,
DescribeRefreshSchemasStatusError::Credentials(ref err) => err.description(),
DescribeRefreshSchemasStatusError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeRefreshSchemasStatusError::ParseError(ref cause) => cause,
DescribeRefreshSchemasStatusError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeReplicationInstanceTaskLogsError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeReplicationInstanceTaskLogsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeReplicationInstanceTaskLogsError {
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 {
"InvalidResourceStateFault" => {
return DescribeReplicationInstanceTaskLogsError::InvalidResourceStateFault(
String::from(error_message),
)
}
"ResourceNotFoundFault" => {
return DescribeReplicationInstanceTaskLogsError::ResourceNotFoundFault(
String::from(error_message),
)
}
"ValidationException" => {
return DescribeReplicationInstanceTaskLogsError::Validation(
error_message.to_string(),
)
}
_ => {}
}
}
return DescribeReplicationInstanceTaskLogsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeReplicationInstanceTaskLogsError {
fn from(err: serde_json::error::Error) -> DescribeReplicationInstanceTaskLogsError {
DescribeReplicationInstanceTaskLogsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeReplicationInstanceTaskLogsError {
fn from(err: CredentialsError) -> DescribeReplicationInstanceTaskLogsError {
DescribeReplicationInstanceTaskLogsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeReplicationInstanceTaskLogsError {
fn from(err: HttpDispatchError) -> DescribeReplicationInstanceTaskLogsError {
DescribeReplicationInstanceTaskLogsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeReplicationInstanceTaskLogsError {
fn from(err: io::Error) -> DescribeReplicationInstanceTaskLogsError {
DescribeReplicationInstanceTaskLogsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeReplicationInstanceTaskLogsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeReplicationInstanceTaskLogsError {
fn description(&self) -> &str {
match *self {
DescribeReplicationInstanceTaskLogsError::InvalidResourceStateFault(ref cause) => cause,
DescribeReplicationInstanceTaskLogsError::ResourceNotFoundFault(ref cause) => cause,
DescribeReplicationInstanceTaskLogsError::Validation(ref cause) => cause,
DescribeReplicationInstanceTaskLogsError::Credentials(ref err) => err.description(),
DescribeReplicationInstanceTaskLogsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeReplicationInstanceTaskLogsError::ParseError(ref cause) => cause,
DescribeReplicationInstanceTaskLogsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeReplicationInstancesError {
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeReplicationInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeReplicationInstancesError {
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 {
"ResourceNotFoundFault" => {
return DescribeReplicationInstancesError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return DescribeReplicationInstancesError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeReplicationInstancesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeReplicationInstancesError {
fn from(err: serde_json::error::Error) -> DescribeReplicationInstancesError {
DescribeReplicationInstancesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeReplicationInstancesError {
fn from(err: CredentialsError) -> DescribeReplicationInstancesError {
DescribeReplicationInstancesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeReplicationInstancesError {
fn from(err: HttpDispatchError) -> DescribeReplicationInstancesError {
DescribeReplicationInstancesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeReplicationInstancesError {
fn from(err: io::Error) -> DescribeReplicationInstancesError {
DescribeReplicationInstancesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeReplicationInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeReplicationInstancesError {
fn description(&self) -> &str {
match *self {
DescribeReplicationInstancesError::ResourceNotFoundFault(ref cause) => cause,
DescribeReplicationInstancesError::Validation(ref cause) => cause,
DescribeReplicationInstancesError::Credentials(ref err) => err.description(),
DescribeReplicationInstancesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeReplicationInstancesError::ParseError(ref cause) => cause,
DescribeReplicationInstancesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeReplicationSubnetGroupsError {
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeReplicationSubnetGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeReplicationSubnetGroupsError {
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 {
"ResourceNotFoundFault" => {
return DescribeReplicationSubnetGroupsError::ResourceNotFoundFault(
String::from(error_message),
)
}
"ValidationException" => {
return DescribeReplicationSubnetGroupsError::Validation(
error_message.to_string(),
)
}
_ => {}
}
}
return DescribeReplicationSubnetGroupsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeReplicationSubnetGroupsError {
fn from(err: serde_json::error::Error) -> DescribeReplicationSubnetGroupsError {
DescribeReplicationSubnetGroupsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeReplicationSubnetGroupsError {
fn from(err: CredentialsError) -> DescribeReplicationSubnetGroupsError {
DescribeReplicationSubnetGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeReplicationSubnetGroupsError {
fn from(err: HttpDispatchError) -> DescribeReplicationSubnetGroupsError {
DescribeReplicationSubnetGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeReplicationSubnetGroupsError {
fn from(err: io::Error) -> DescribeReplicationSubnetGroupsError {
DescribeReplicationSubnetGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeReplicationSubnetGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeReplicationSubnetGroupsError {
fn description(&self) -> &str {
match *self {
DescribeReplicationSubnetGroupsError::ResourceNotFoundFault(ref cause) => cause,
DescribeReplicationSubnetGroupsError::Validation(ref cause) => cause,
DescribeReplicationSubnetGroupsError::Credentials(ref err) => err.description(),
DescribeReplicationSubnetGroupsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeReplicationSubnetGroupsError::ParseError(ref cause) => cause,
DescribeReplicationSubnetGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeReplicationTaskAssessmentResultsError {
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeReplicationTaskAssessmentResultsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> DescribeReplicationTaskAssessmentResultsError {
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 {
"ResourceNotFoundFault" => {
return DescribeReplicationTaskAssessmentResultsError::ResourceNotFoundFault(
String::from(error_message),
)
}
"ValidationException" => {
return DescribeReplicationTaskAssessmentResultsError::Validation(
error_message.to_string(),
)
}
_ => {}
}
}
return DescribeReplicationTaskAssessmentResultsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeReplicationTaskAssessmentResultsError {
fn from(err: serde_json::error::Error) -> DescribeReplicationTaskAssessmentResultsError {
DescribeReplicationTaskAssessmentResultsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeReplicationTaskAssessmentResultsError {
fn from(err: CredentialsError) -> DescribeReplicationTaskAssessmentResultsError {
DescribeReplicationTaskAssessmentResultsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeReplicationTaskAssessmentResultsError {
fn from(err: HttpDispatchError) -> DescribeReplicationTaskAssessmentResultsError {
DescribeReplicationTaskAssessmentResultsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeReplicationTaskAssessmentResultsError {
fn from(err: io::Error) -> DescribeReplicationTaskAssessmentResultsError {
DescribeReplicationTaskAssessmentResultsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeReplicationTaskAssessmentResultsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeReplicationTaskAssessmentResultsError {
fn description(&self) -> &str {
match *self {
DescribeReplicationTaskAssessmentResultsError::ResourceNotFoundFault(ref cause) => {
cause
}
DescribeReplicationTaskAssessmentResultsError::Validation(ref cause) => cause,
DescribeReplicationTaskAssessmentResultsError::Credentials(ref err) => {
err.description()
}
DescribeReplicationTaskAssessmentResultsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeReplicationTaskAssessmentResultsError::ParseError(ref cause) => cause,
DescribeReplicationTaskAssessmentResultsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeReplicationTasksError {
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeReplicationTasksError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeReplicationTasksError {
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 {
"ResourceNotFoundFault" => {
return DescribeReplicationTasksError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return DescribeReplicationTasksError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeReplicationTasksError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeReplicationTasksError {
fn from(err: serde_json::error::Error) -> DescribeReplicationTasksError {
DescribeReplicationTasksError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeReplicationTasksError {
fn from(err: CredentialsError) -> DescribeReplicationTasksError {
DescribeReplicationTasksError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeReplicationTasksError {
fn from(err: HttpDispatchError) -> DescribeReplicationTasksError {
DescribeReplicationTasksError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeReplicationTasksError {
fn from(err: io::Error) -> DescribeReplicationTasksError {
DescribeReplicationTasksError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeReplicationTasksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeReplicationTasksError {
fn description(&self) -> &str {
match *self {
DescribeReplicationTasksError::ResourceNotFoundFault(ref cause) => cause,
DescribeReplicationTasksError::Validation(ref cause) => cause,
DescribeReplicationTasksError::Credentials(ref err) => err.description(),
DescribeReplicationTasksError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeReplicationTasksError::ParseError(ref cause) => cause,
DescribeReplicationTasksError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSchemasError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeSchemasError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeSchemasError {
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 {
"InvalidResourceStateFault" => {
return DescribeSchemasError::InvalidResourceStateFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return DescribeSchemasError::ResourceNotFoundFault(String::from(error_message))
}
"ValidationException" => {
return DescribeSchemasError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeSchemasError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeSchemasError {
fn from(err: serde_json::error::Error) -> DescribeSchemasError {
DescribeSchemasError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeSchemasError {
fn from(err: CredentialsError) -> DescribeSchemasError {
DescribeSchemasError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeSchemasError {
fn from(err: HttpDispatchError) -> DescribeSchemasError {
DescribeSchemasError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeSchemasError {
fn from(err: io::Error) -> DescribeSchemasError {
DescribeSchemasError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeSchemasError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSchemasError {
fn description(&self) -> &str {
match *self {
DescribeSchemasError::InvalidResourceStateFault(ref cause) => cause,
DescribeSchemasError::ResourceNotFoundFault(ref cause) => cause,
DescribeSchemasError::Validation(ref cause) => cause,
DescribeSchemasError::Credentials(ref err) => err.description(),
DescribeSchemasError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeSchemasError::ParseError(ref cause) => cause,
DescribeSchemasError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeTableStatisticsError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeTableStatisticsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeTableStatisticsError {
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 {
"InvalidResourceStateFault" => {
return DescribeTableStatisticsError::InvalidResourceStateFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return DescribeTableStatisticsError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return DescribeTableStatisticsError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeTableStatisticsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeTableStatisticsError {
fn from(err: serde_json::error::Error) -> DescribeTableStatisticsError {
DescribeTableStatisticsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeTableStatisticsError {
fn from(err: CredentialsError) -> DescribeTableStatisticsError {
DescribeTableStatisticsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeTableStatisticsError {
fn from(err: HttpDispatchError) -> DescribeTableStatisticsError {
DescribeTableStatisticsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeTableStatisticsError {
fn from(err: io::Error) -> DescribeTableStatisticsError {
DescribeTableStatisticsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeTableStatisticsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeTableStatisticsError {
fn description(&self) -> &str {
match *self {
DescribeTableStatisticsError::InvalidResourceStateFault(ref cause) => cause,
DescribeTableStatisticsError::ResourceNotFoundFault(ref cause) => cause,
DescribeTableStatisticsError::Validation(ref cause) => cause,
DescribeTableStatisticsError::Credentials(ref err) => err.description(),
DescribeTableStatisticsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeTableStatisticsError::ParseError(ref cause) => cause,
DescribeTableStatisticsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ImportCertificateError {
InvalidCertificateFault(String),
ResourceAlreadyExistsFault(String),
ResourceQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ImportCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> ImportCertificateError {
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 {
"InvalidCertificateFault" => {
return ImportCertificateError::InvalidCertificateFault(String::from(
error_message,
))
}
"ResourceAlreadyExistsFault" => {
return ImportCertificateError::ResourceAlreadyExistsFault(String::from(
error_message,
))
}
"ResourceQuotaExceededFault" => {
return ImportCertificateError::ResourceQuotaExceededFault(String::from(
error_message,
))
}
"ValidationException" => {
return ImportCertificateError::Validation(error_message.to_string())
}
_ => {}
}
}
return ImportCertificateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ImportCertificateError {
fn from(err: serde_json::error::Error) -> ImportCertificateError {
ImportCertificateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ImportCertificateError {
fn from(err: CredentialsError) -> ImportCertificateError {
ImportCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for ImportCertificateError {
fn from(err: HttpDispatchError) -> ImportCertificateError {
ImportCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for ImportCertificateError {
fn from(err: io::Error) -> ImportCertificateError {
ImportCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ImportCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ImportCertificateError {
fn description(&self) -> &str {
match *self {
ImportCertificateError::InvalidCertificateFault(ref cause) => cause,
ImportCertificateError::ResourceAlreadyExistsFault(ref cause) => cause,
ImportCertificateError::ResourceQuotaExceededFault(ref cause) => cause,
ImportCertificateError::Validation(ref cause) => cause,
ImportCertificateError::Credentials(ref err) => err.description(),
ImportCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ImportCertificateError::ParseError(ref cause) => cause,
ImportCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> ListTagsForResourceError {
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 {
"ResourceNotFoundFault" => {
return ListTagsForResourceError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return ListTagsForResourceError::Validation(error_message.to_string())
}
_ => {}
}
}
return ListTagsForResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListTagsForResourceError {
fn from(err: serde_json::error::Error) -> ListTagsForResourceError {
ListTagsForResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListTagsForResourceError {
fn from(err: CredentialsError) -> ListTagsForResourceError {
ListTagsForResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTagsForResourceError {
fn from(err: HttpDispatchError) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTagsForResourceError {
fn from(err: io::Error) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTagsForResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTagsForResourceError {
fn description(&self) -> &str {
match *self {
ListTagsForResourceError::ResourceNotFoundFault(ref cause) => cause,
ListTagsForResourceError::Validation(ref cause) => cause,
ListTagsForResourceError::Credentials(ref err) => err.description(),
ListTagsForResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTagsForResourceError::ParseError(ref cause) => cause,
ListTagsForResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyEndpointError {
AccessDeniedFault(String),
InvalidResourceStateFault(String),
KMSKeyNotAccessibleFault(String),
ResourceAlreadyExistsFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyEndpointError {
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 {
"AccessDeniedFault" => {
return ModifyEndpointError::AccessDeniedFault(String::from(error_message))
}
"InvalidResourceStateFault" => {
return ModifyEndpointError::InvalidResourceStateFault(String::from(
error_message,
))
}
"KMSKeyNotAccessibleFault" => {
return ModifyEndpointError::KMSKeyNotAccessibleFault(String::from(
error_message,
))
}
"ResourceAlreadyExistsFault" => {
return ModifyEndpointError::ResourceAlreadyExistsFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return ModifyEndpointError::ResourceNotFoundFault(String::from(error_message))
}
"ValidationException" => {
return ModifyEndpointError::Validation(error_message.to_string())
}
_ => {}
}
}
return ModifyEndpointError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ModifyEndpointError {
fn from(err: serde_json::error::Error) -> ModifyEndpointError {
ModifyEndpointError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ModifyEndpointError {
fn from(err: CredentialsError) -> ModifyEndpointError {
ModifyEndpointError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyEndpointError {
fn from(err: HttpDispatchError) -> ModifyEndpointError {
ModifyEndpointError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyEndpointError {
fn from(err: io::Error) -> ModifyEndpointError {
ModifyEndpointError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyEndpointError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyEndpointError {
fn description(&self) -> &str {
match *self {
ModifyEndpointError::AccessDeniedFault(ref cause) => cause,
ModifyEndpointError::InvalidResourceStateFault(ref cause) => cause,
ModifyEndpointError::KMSKeyNotAccessibleFault(ref cause) => cause,
ModifyEndpointError::ResourceAlreadyExistsFault(ref cause) => cause,
ModifyEndpointError::ResourceNotFoundFault(ref cause) => cause,
ModifyEndpointError::Validation(ref cause) => cause,
ModifyEndpointError::Credentials(ref err) => err.description(),
ModifyEndpointError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ModifyEndpointError::ParseError(ref cause) => cause,
ModifyEndpointError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyEventSubscriptionError {
ResourceNotFoundFault(String),
ResourceQuotaExceededFault(String),
SNSInvalidTopicFault(String),
SNSNoAuthorizationFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyEventSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyEventSubscriptionError {
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 {
"ResourceNotFoundFault" => {
return ModifyEventSubscriptionError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ResourceQuotaExceededFault" => {
return ModifyEventSubscriptionError::ResourceQuotaExceededFault(String::from(
error_message,
))
}
"SNSInvalidTopicFault" => {
return ModifyEventSubscriptionError::SNSInvalidTopicFault(String::from(
error_message,
))
}
"SNSNoAuthorizationFault" => {
return ModifyEventSubscriptionError::SNSNoAuthorizationFault(String::from(
error_message,
))
}
"ValidationException" => {
return ModifyEventSubscriptionError::Validation(error_message.to_string())
}
_ => {}
}
}
return ModifyEventSubscriptionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ModifyEventSubscriptionError {
fn from(err: serde_json::error::Error) -> ModifyEventSubscriptionError {
ModifyEventSubscriptionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ModifyEventSubscriptionError {
fn from(err: CredentialsError) -> ModifyEventSubscriptionError {
ModifyEventSubscriptionError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyEventSubscriptionError {
fn from(err: HttpDispatchError) -> ModifyEventSubscriptionError {
ModifyEventSubscriptionError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyEventSubscriptionError {
fn from(err: io::Error) -> ModifyEventSubscriptionError {
ModifyEventSubscriptionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyEventSubscriptionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyEventSubscriptionError {
fn description(&self) -> &str {
match *self {
ModifyEventSubscriptionError::ResourceNotFoundFault(ref cause) => cause,
ModifyEventSubscriptionError::ResourceQuotaExceededFault(ref cause) => cause,
ModifyEventSubscriptionError::SNSInvalidTopicFault(ref cause) => cause,
ModifyEventSubscriptionError::SNSNoAuthorizationFault(ref cause) => cause,
ModifyEventSubscriptionError::Validation(ref cause) => cause,
ModifyEventSubscriptionError::Credentials(ref err) => err.description(),
ModifyEventSubscriptionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifyEventSubscriptionError::ParseError(ref cause) => cause,
ModifyEventSubscriptionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyReplicationInstanceError {
InsufficientResourceCapacityFault(String),
InvalidResourceStateFault(String),
ResourceAlreadyExistsFault(String),
ResourceNotFoundFault(String),
StorageQuotaExceededFault(String),
UpgradeDependencyFailureFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyReplicationInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyReplicationInstanceError {
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 {
"InsufficientResourceCapacityFault" => {
return ModifyReplicationInstanceError::InsufficientResourceCapacityFault(
String::from(error_message),
)
}
"InvalidResourceStateFault" => {
return ModifyReplicationInstanceError::InvalidResourceStateFault(String::from(
error_message,
))
}
"ResourceAlreadyExistsFault" => {
return ModifyReplicationInstanceError::ResourceAlreadyExistsFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return ModifyReplicationInstanceError::ResourceNotFoundFault(String::from(
error_message,
))
}
"StorageQuotaExceededFault" => {
return ModifyReplicationInstanceError::StorageQuotaExceededFault(String::from(
error_message,
))
}
"UpgradeDependencyFailureFault" => {
return ModifyReplicationInstanceError::UpgradeDependencyFailureFault(
String::from(error_message),
)
}
"ValidationException" => {
return ModifyReplicationInstanceError::Validation(error_message.to_string())
}
_ => {}
}
}
return ModifyReplicationInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ModifyReplicationInstanceError {
fn from(err: serde_json::error::Error) -> ModifyReplicationInstanceError {
ModifyReplicationInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ModifyReplicationInstanceError {
fn from(err: CredentialsError) -> ModifyReplicationInstanceError {
ModifyReplicationInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyReplicationInstanceError {
fn from(err: HttpDispatchError) -> ModifyReplicationInstanceError {
ModifyReplicationInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyReplicationInstanceError {
fn from(err: io::Error) -> ModifyReplicationInstanceError {
ModifyReplicationInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyReplicationInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyReplicationInstanceError {
fn description(&self) -> &str {
match *self {
ModifyReplicationInstanceError::InsufficientResourceCapacityFault(ref cause) => cause,
ModifyReplicationInstanceError::InvalidResourceStateFault(ref cause) => cause,
ModifyReplicationInstanceError::ResourceAlreadyExistsFault(ref cause) => cause,
ModifyReplicationInstanceError::ResourceNotFoundFault(ref cause) => cause,
ModifyReplicationInstanceError::StorageQuotaExceededFault(ref cause) => cause,
ModifyReplicationInstanceError::UpgradeDependencyFailureFault(ref cause) => cause,
ModifyReplicationInstanceError::Validation(ref cause) => cause,
ModifyReplicationInstanceError::Credentials(ref err) => err.description(),
ModifyReplicationInstanceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifyReplicationInstanceError::ParseError(ref cause) => cause,
ModifyReplicationInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyReplicationSubnetGroupError {
AccessDeniedFault(String),
InvalidSubnet(String),
ReplicationSubnetGroupDoesNotCoverEnoughAZs(String),
ResourceNotFoundFault(String),
ResourceQuotaExceededFault(String),
SubnetAlreadyInUse(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyReplicationSubnetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyReplicationSubnetGroupError {
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 {
"AccessDeniedFault" => return ModifyReplicationSubnetGroupError::AccessDeniedFault(String::from(error_message)),
"InvalidSubnet" => return ModifyReplicationSubnetGroupError::InvalidSubnet(String::from(error_message)),
"ReplicationSubnetGroupDoesNotCoverEnoughAZs" => return ModifyReplicationSubnetGroupError::ReplicationSubnetGroupDoesNotCoverEnoughAZs(String::from(error_message)),
"ResourceNotFoundFault" => return ModifyReplicationSubnetGroupError::ResourceNotFoundFault(String::from(error_message)),
"ResourceQuotaExceededFault" => return ModifyReplicationSubnetGroupError::ResourceQuotaExceededFault(String::from(error_message)),
"SubnetAlreadyInUse" => return ModifyReplicationSubnetGroupError::SubnetAlreadyInUse(String::from(error_message)),
"ValidationException" => return ModifyReplicationSubnetGroupError::Validation(error_message.to_string()),
_ => {}
}
}
return ModifyReplicationSubnetGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ModifyReplicationSubnetGroupError {
fn from(err: serde_json::error::Error) -> ModifyReplicationSubnetGroupError {
ModifyReplicationSubnetGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ModifyReplicationSubnetGroupError {
fn from(err: CredentialsError) -> ModifyReplicationSubnetGroupError {
ModifyReplicationSubnetGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyReplicationSubnetGroupError {
fn from(err: HttpDispatchError) -> ModifyReplicationSubnetGroupError {
ModifyReplicationSubnetGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyReplicationSubnetGroupError {
fn from(err: io::Error) -> ModifyReplicationSubnetGroupError {
ModifyReplicationSubnetGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyReplicationSubnetGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyReplicationSubnetGroupError {
fn description(&self) -> &str {
match *self {
ModifyReplicationSubnetGroupError::AccessDeniedFault(ref cause) => cause,
ModifyReplicationSubnetGroupError::InvalidSubnet(ref cause) => cause,
ModifyReplicationSubnetGroupError::ReplicationSubnetGroupDoesNotCoverEnoughAZs(
ref cause,
) => cause,
ModifyReplicationSubnetGroupError::ResourceNotFoundFault(ref cause) => cause,
ModifyReplicationSubnetGroupError::ResourceQuotaExceededFault(ref cause) => cause,
ModifyReplicationSubnetGroupError::SubnetAlreadyInUse(ref cause) => cause,
ModifyReplicationSubnetGroupError::Validation(ref cause) => cause,
ModifyReplicationSubnetGroupError::Credentials(ref err) => err.description(),
ModifyReplicationSubnetGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifyReplicationSubnetGroupError::ParseError(ref cause) => cause,
ModifyReplicationSubnetGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ModifyReplicationTaskError {
InvalidResourceStateFault(String),
KMSKeyNotAccessibleFault(String),
ResourceAlreadyExistsFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ModifyReplicationTaskError {
pub fn from_response(res: BufferedHttpResponse) -> ModifyReplicationTaskError {
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 {
"InvalidResourceStateFault" => {
return ModifyReplicationTaskError::InvalidResourceStateFault(String::from(
error_message,
))
}
"KMSKeyNotAccessibleFault" => {
return ModifyReplicationTaskError::KMSKeyNotAccessibleFault(String::from(
error_message,
))
}
"ResourceAlreadyExistsFault" => {
return ModifyReplicationTaskError::ResourceAlreadyExistsFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return ModifyReplicationTaskError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return ModifyReplicationTaskError::Validation(error_message.to_string())
}
_ => {}
}
}
return ModifyReplicationTaskError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ModifyReplicationTaskError {
fn from(err: serde_json::error::Error) -> ModifyReplicationTaskError {
ModifyReplicationTaskError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ModifyReplicationTaskError {
fn from(err: CredentialsError) -> ModifyReplicationTaskError {
ModifyReplicationTaskError::Credentials(err)
}
}
impl From<HttpDispatchError> for ModifyReplicationTaskError {
fn from(err: HttpDispatchError) -> ModifyReplicationTaskError {
ModifyReplicationTaskError::HttpDispatch(err)
}
}
impl From<io::Error> for ModifyReplicationTaskError {
fn from(err: io::Error) -> ModifyReplicationTaskError {
ModifyReplicationTaskError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ModifyReplicationTaskError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ModifyReplicationTaskError {
fn description(&self) -> &str {
match *self {
ModifyReplicationTaskError::InvalidResourceStateFault(ref cause) => cause,
ModifyReplicationTaskError::KMSKeyNotAccessibleFault(ref cause) => cause,
ModifyReplicationTaskError::ResourceAlreadyExistsFault(ref cause) => cause,
ModifyReplicationTaskError::ResourceNotFoundFault(ref cause) => cause,
ModifyReplicationTaskError::Validation(ref cause) => cause,
ModifyReplicationTaskError::Credentials(ref err) => err.description(),
ModifyReplicationTaskError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ModifyReplicationTaskError::ParseError(ref cause) => cause,
ModifyReplicationTaskError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RebootReplicationInstanceError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RebootReplicationInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RebootReplicationInstanceError {
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 {
"InvalidResourceStateFault" => {
return RebootReplicationInstanceError::InvalidResourceStateFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return RebootReplicationInstanceError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return RebootReplicationInstanceError::Validation(error_message.to_string())
}
_ => {}
}
}
return RebootReplicationInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RebootReplicationInstanceError {
fn from(err: serde_json::error::Error) -> RebootReplicationInstanceError {
RebootReplicationInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RebootReplicationInstanceError {
fn from(err: CredentialsError) -> RebootReplicationInstanceError {
RebootReplicationInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for RebootReplicationInstanceError {
fn from(err: HttpDispatchError) -> RebootReplicationInstanceError {
RebootReplicationInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for RebootReplicationInstanceError {
fn from(err: io::Error) -> RebootReplicationInstanceError {
RebootReplicationInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RebootReplicationInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RebootReplicationInstanceError {
fn description(&self) -> &str {
match *self {
RebootReplicationInstanceError::InvalidResourceStateFault(ref cause) => cause,
RebootReplicationInstanceError::ResourceNotFoundFault(ref cause) => cause,
RebootReplicationInstanceError::Validation(ref cause) => cause,
RebootReplicationInstanceError::Credentials(ref err) => err.description(),
RebootReplicationInstanceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RebootReplicationInstanceError::ParseError(ref cause) => cause,
RebootReplicationInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RefreshSchemasError {
InvalidResourceStateFault(String),
KMSKeyNotAccessibleFault(String),
ResourceNotFoundFault(String),
ResourceQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RefreshSchemasError {
pub fn from_response(res: BufferedHttpResponse) -> RefreshSchemasError {
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 {
"InvalidResourceStateFault" => {
return RefreshSchemasError::InvalidResourceStateFault(String::from(
error_message,
))
}
"KMSKeyNotAccessibleFault" => {
return RefreshSchemasError::KMSKeyNotAccessibleFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return RefreshSchemasError::ResourceNotFoundFault(String::from(error_message))
}
"ResourceQuotaExceededFault" => {
return RefreshSchemasError::ResourceQuotaExceededFault(String::from(
error_message,
))
}
"ValidationException" => {
return RefreshSchemasError::Validation(error_message.to_string())
}
_ => {}
}
}
return RefreshSchemasError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RefreshSchemasError {
fn from(err: serde_json::error::Error) -> RefreshSchemasError {
RefreshSchemasError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RefreshSchemasError {
fn from(err: CredentialsError) -> RefreshSchemasError {
RefreshSchemasError::Credentials(err)
}
}
impl From<HttpDispatchError> for RefreshSchemasError {
fn from(err: HttpDispatchError) -> RefreshSchemasError {
RefreshSchemasError::HttpDispatch(err)
}
}
impl From<io::Error> for RefreshSchemasError {
fn from(err: io::Error) -> RefreshSchemasError {
RefreshSchemasError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RefreshSchemasError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RefreshSchemasError {
fn description(&self) -> &str {
match *self {
RefreshSchemasError::InvalidResourceStateFault(ref cause) => cause,
RefreshSchemasError::KMSKeyNotAccessibleFault(ref cause) => cause,
RefreshSchemasError::ResourceNotFoundFault(ref cause) => cause,
RefreshSchemasError::ResourceQuotaExceededFault(ref cause) => cause,
RefreshSchemasError::Validation(ref cause) => cause,
RefreshSchemasError::Credentials(ref err) => err.description(),
RefreshSchemasError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
RefreshSchemasError::ParseError(ref cause) => cause,
RefreshSchemasError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ReloadTablesError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ReloadTablesError {
pub fn from_response(res: BufferedHttpResponse) -> ReloadTablesError {
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 {
"InvalidResourceStateFault" => {
return ReloadTablesError::InvalidResourceStateFault(String::from(error_message))
}
"ResourceNotFoundFault" => {
return ReloadTablesError::ResourceNotFoundFault(String::from(error_message))
}
"ValidationException" => {
return ReloadTablesError::Validation(error_message.to_string())
}
_ => {}
}
}
return ReloadTablesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ReloadTablesError {
fn from(err: serde_json::error::Error) -> ReloadTablesError {
ReloadTablesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ReloadTablesError {
fn from(err: CredentialsError) -> ReloadTablesError {
ReloadTablesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ReloadTablesError {
fn from(err: HttpDispatchError) -> ReloadTablesError {
ReloadTablesError::HttpDispatch(err)
}
}
impl From<io::Error> for ReloadTablesError {
fn from(err: io::Error) -> ReloadTablesError {
ReloadTablesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ReloadTablesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ReloadTablesError {
fn description(&self) -> &str {
match *self {
ReloadTablesError::InvalidResourceStateFault(ref cause) => cause,
ReloadTablesError::ResourceNotFoundFault(ref cause) => cause,
ReloadTablesError::Validation(ref cause) => cause,
ReloadTablesError::Credentials(ref err) => err.description(),
ReloadTablesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ReloadTablesError::ParseError(ref cause) => cause,
ReloadTablesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RemoveTagsFromResourceError {
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RemoveTagsFromResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RemoveTagsFromResourceError {
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 {
"ResourceNotFoundFault" => {
return RemoveTagsFromResourceError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return RemoveTagsFromResourceError::Validation(error_message.to_string())
}
_ => {}
}
}
return RemoveTagsFromResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RemoveTagsFromResourceError {
fn from(err: serde_json::error::Error) -> RemoveTagsFromResourceError {
RemoveTagsFromResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RemoveTagsFromResourceError {
fn from(err: CredentialsError) -> RemoveTagsFromResourceError {
RemoveTagsFromResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for RemoveTagsFromResourceError {
fn from(err: HttpDispatchError) -> RemoveTagsFromResourceError {
RemoveTagsFromResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for RemoveTagsFromResourceError {
fn from(err: io::Error) -> RemoveTagsFromResourceError {
RemoveTagsFromResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RemoveTagsFromResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RemoveTagsFromResourceError {
fn description(&self) -> &str {
match *self {
RemoveTagsFromResourceError::ResourceNotFoundFault(ref cause) => cause,
RemoveTagsFromResourceError::Validation(ref cause) => cause,
RemoveTagsFromResourceError::Credentials(ref err) => err.description(),
RemoveTagsFromResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RemoveTagsFromResourceError::ParseError(ref cause) => cause,
RemoveTagsFromResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartReplicationTaskError {
AccessDeniedFault(String),
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartReplicationTaskError {
pub fn from_response(res: BufferedHttpResponse) -> StartReplicationTaskError {
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 {
"AccessDeniedFault" => {
return StartReplicationTaskError::AccessDeniedFault(String::from(error_message))
}
"InvalidResourceStateFault" => {
return StartReplicationTaskError::InvalidResourceStateFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return StartReplicationTaskError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return StartReplicationTaskError::Validation(error_message.to_string())
}
_ => {}
}
}
return StartReplicationTaskError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartReplicationTaskError {
fn from(err: serde_json::error::Error) -> StartReplicationTaskError {
StartReplicationTaskError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartReplicationTaskError {
fn from(err: CredentialsError) -> StartReplicationTaskError {
StartReplicationTaskError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartReplicationTaskError {
fn from(err: HttpDispatchError) -> StartReplicationTaskError {
StartReplicationTaskError::HttpDispatch(err)
}
}
impl From<io::Error> for StartReplicationTaskError {
fn from(err: io::Error) -> StartReplicationTaskError {
StartReplicationTaskError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartReplicationTaskError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartReplicationTaskError {
fn description(&self) -> &str {
match *self {
StartReplicationTaskError::AccessDeniedFault(ref cause) => cause,
StartReplicationTaskError::InvalidResourceStateFault(ref cause) => cause,
StartReplicationTaskError::ResourceNotFoundFault(ref cause) => cause,
StartReplicationTaskError::Validation(ref cause) => cause,
StartReplicationTaskError::Credentials(ref err) => err.description(),
StartReplicationTaskError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
StartReplicationTaskError::ParseError(ref cause) => cause,
StartReplicationTaskError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartReplicationTaskAssessmentError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartReplicationTaskAssessmentError {
pub fn from_response(res: BufferedHttpResponse) -> StartReplicationTaskAssessmentError {
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 {
"InvalidResourceStateFault" => {
return StartReplicationTaskAssessmentError::InvalidResourceStateFault(
String::from(error_message),
)
}
"ResourceNotFoundFault" => {
return StartReplicationTaskAssessmentError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return StartReplicationTaskAssessmentError::Validation(
error_message.to_string(),
)
}
_ => {}
}
}
return StartReplicationTaskAssessmentError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartReplicationTaskAssessmentError {
fn from(err: serde_json::error::Error) -> StartReplicationTaskAssessmentError {
StartReplicationTaskAssessmentError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartReplicationTaskAssessmentError {
fn from(err: CredentialsError) -> StartReplicationTaskAssessmentError {
StartReplicationTaskAssessmentError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartReplicationTaskAssessmentError {
fn from(err: HttpDispatchError) -> StartReplicationTaskAssessmentError {
StartReplicationTaskAssessmentError::HttpDispatch(err)
}
}
impl From<io::Error> for StartReplicationTaskAssessmentError {
fn from(err: io::Error) -> StartReplicationTaskAssessmentError {
StartReplicationTaskAssessmentError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartReplicationTaskAssessmentError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartReplicationTaskAssessmentError {
fn description(&self) -> &str {
match *self {
StartReplicationTaskAssessmentError::InvalidResourceStateFault(ref cause) => cause,
StartReplicationTaskAssessmentError::ResourceNotFoundFault(ref cause) => cause,
StartReplicationTaskAssessmentError::Validation(ref cause) => cause,
StartReplicationTaskAssessmentError::Credentials(ref err) => err.description(),
StartReplicationTaskAssessmentError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
StartReplicationTaskAssessmentError::ParseError(ref cause) => cause,
StartReplicationTaskAssessmentError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StopReplicationTaskError {
InvalidResourceStateFault(String),
ResourceNotFoundFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StopReplicationTaskError {
pub fn from_response(res: BufferedHttpResponse) -> StopReplicationTaskError {
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 {
"InvalidResourceStateFault" => {
return StopReplicationTaskError::InvalidResourceStateFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return StopReplicationTaskError::ResourceNotFoundFault(String::from(
error_message,
))
}
"ValidationException" => {
return StopReplicationTaskError::Validation(error_message.to_string())
}
_ => {}
}
}
return StopReplicationTaskError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StopReplicationTaskError {
fn from(err: serde_json::error::Error) -> StopReplicationTaskError {
StopReplicationTaskError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StopReplicationTaskError {
fn from(err: CredentialsError) -> StopReplicationTaskError {
StopReplicationTaskError::Credentials(err)
}
}
impl From<HttpDispatchError> for StopReplicationTaskError {
fn from(err: HttpDispatchError) -> StopReplicationTaskError {
StopReplicationTaskError::HttpDispatch(err)
}
}
impl From<io::Error> for StopReplicationTaskError {
fn from(err: io::Error) -> StopReplicationTaskError {
StopReplicationTaskError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StopReplicationTaskError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StopReplicationTaskError {
fn description(&self) -> &str {
match *self {
StopReplicationTaskError::InvalidResourceStateFault(ref cause) => cause,
StopReplicationTaskError::ResourceNotFoundFault(ref cause) => cause,
StopReplicationTaskError::Validation(ref cause) => cause,
StopReplicationTaskError::Credentials(ref err) => err.description(),
StopReplicationTaskError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
StopReplicationTaskError::ParseError(ref cause) => cause,
StopReplicationTaskError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum TestConnectionError {
InvalidResourceStateFault(String),
KMSKeyNotAccessibleFault(String),
ResourceNotFoundFault(String),
ResourceQuotaExceededFault(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl TestConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> TestConnectionError {
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 {
"InvalidResourceStateFault" => {
return TestConnectionError::InvalidResourceStateFault(String::from(
error_message,
))
}
"KMSKeyNotAccessibleFault" => {
return TestConnectionError::KMSKeyNotAccessibleFault(String::from(
error_message,
))
}
"ResourceNotFoundFault" => {
return TestConnectionError::ResourceNotFoundFault(String::from(error_message))
}
"ResourceQuotaExceededFault" => {
return TestConnectionError::ResourceQuotaExceededFault(String::from(
error_message,
))
}
"ValidationException" => {
return TestConnectionError::Validation(error_message.to_string())
}
_ => {}
}
}
return TestConnectionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for TestConnectionError {
fn from(err: serde_json::error::Error) -> TestConnectionError {
TestConnectionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for TestConnectionError {
fn from(err: CredentialsError) -> TestConnectionError {
TestConnectionError::Credentials(err)
}
}
impl From<HttpDispatchError> for TestConnectionError {
fn from(err: HttpDispatchError) -> TestConnectionError {
TestConnectionError::HttpDispatch(err)
}
}
impl From<io::Error> for TestConnectionError {
fn from(err: io::Error) -> TestConnectionError {
TestConnectionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for TestConnectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for TestConnectionError {
fn description(&self) -> &str {
match *self {
TestConnectionError::InvalidResourceStateFault(ref cause) => cause,
TestConnectionError::KMSKeyNotAccessibleFault(ref cause) => cause,
TestConnectionError::ResourceNotFoundFault(ref cause) => cause,
TestConnectionError::ResourceQuotaExceededFault(ref cause) => cause,
TestConnectionError::Validation(ref cause) => cause,
TestConnectionError::Credentials(ref err) => err.description(),
TestConnectionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
TestConnectionError::ParseError(ref cause) => cause,
TestConnectionError::Unknown(_) => "unknown error",
}
}
}
pub trait DatabaseMigrationService {
fn add_tags_to_resource(
&self,
input: AddTagsToResourceMessage,
) -> RusotoFuture<AddTagsToResourceResponse, AddTagsToResourceError>;
fn create_endpoint(
&self,
input: CreateEndpointMessage,
) -> RusotoFuture<CreateEndpointResponse, CreateEndpointError>;
fn create_event_subscription(
&self,
input: CreateEventSubscriptionMessage,
) -> RusotoFuture<CreateEventSubscriptionResponse, CreateEventSubscriptionError>;
fn create_replication_instance(
&self,
input: CreateReplicationInstanceMessage,
) -> RusotoFuture<CreateReplicationInstanceResponse, CreateReplicationInstanceError>;
fn create_replication_subnet_group(
&self,
input: CreateReplicationSubnetGroupMessage,
) -> RusotoFuture<CreateReplicationSubnetGroupResponse, CreateReplicationSubnetGroupError>;
fn create_replication_task(
&self,
input: CreateReplicationTaskMessage,
) -> RusotoFuture<CreateReplicationTaskResponse, CreateReplicationTaskError>;
fn delete_certificate(
&self,
input: DeleteCertificateMessage,
) -> RusotoFuture<DeleteCertificateResponse, DeleteCertificateError>;
fn delete_endpoint(
&self,
input: DeleteEndpointMessage,
) -> RusotoFuture<DeleteEndpointResponse, DeleteEndpointError>;
fn delete_event_subscription(
&self,
input: DeleteEventSubscriptionMessage,
) -> RusotoFuture<DeleteEventSubscriptionResponse, DeleteEventSubscriptionError>;
fn delete_replication_instance(
&self,
input: DeleteReplicationInstanceMessage,
) -> RusotoFuture<DeleteReplicationInstanceResponse, DeleteReplicationInstanceError>;
fn delete_replication_subnet_group(
&self,
input: DeleteReplicationSubnetGroupMessage,
) -> RusotoFuture<DeleteReplicationSubnetGroupResponse, DeleteReplicationSubnetGroupError>;
fn delete_replication_task(
&self,
input: DeleteReplicationTaskMessage,
) -> RusotoFuture<DeleteReplicationTaskResponse, DeleteReplicationTaskError>;
fn describe_account_attributes(
&self,
) -> RusotoFuture<DescribeAccountAttributesResponse, DescribeAccountAttributesError>;
fn describe_certificates(
&self,
input: DescribeCertificatesMessage,
) -> RusotoFuture<DescribeCertificatesResponse, DescribeCertificatesError>;
fn describe_connections(
&self,
input: DescribeConnectionsMessage,
) -> RusotoFuture<DescribeConnectionsResponse, DescribeConnectionsError>;
fn describe_endpoint_types(
&self,
input: DescribeEndpointTypesMessage,
) -> RusotoFuture<DescribeEndpointTypesResponse, DescribeEndpointTypesError>;
fn describe_endpoints(
&self,
input: DescribeEndpointsMessage,
) -> RusotoFuture<DescribeEndpointsResponse, DescribeEndpointsError>;
fn describe_event_categories(
&self,
input: DescribeEventCategoriesMessage,
) -> RusotoFuture<DescribeEventCategoriesResponse, DescribeEventCategoriesError>;
fn describe_event_subscriptions(
&self,
input: DescribeEventSubscriptionsMessage,
) -> RusotoFuture<DescribeEventSubscriptionsResponse, DescribeEventSubscriptionsError>;
fn describe_events(
&self,
input: DescribeEventsMessage,
) -> RusotoFuture<DescribeEventsResponse, DescribeEventsError>;
fn describe_orderable_replication_instances(
&self,
input: DescribeOrderableReplicationInstancesMessage,
) -> RusotoFuture<
DescribeOrderableReplicationInstancesResponse,
DescribeOrderableReplicationInstancesError,
>;
fn describe_refresh_schemas_status(
&self,
input: DescribeRefreshSchemasStatusMessage,
) -> RusotoFuture<DescribeRefreshSchemasStatusResponse, DescribeRefreshSchemasStatusError>;
fn describe_replication_instance_task_logs(
&self,
input: DescribeReplicationInstanceTaskLogsMessage,
) -> RusotoFuture<
DescribeReplicationInstanceTaskLogsResponse,
DescribeReplicationInstanceTaskLogsError,
>;
fn describe_replication_instances(
&self,
input: DescribeReplicationInstancesMessage,
) -> RusotoFuture<DescribeReplicationInstancesResponse, DescribeReplicationInstancesError>;
fn describe_replication_subnet_groups(
&self,
input: DescribeReplicationSubnetGroupsMessage,
) -> RusotoFuture<DescribeReplicationSubnetGroupsResponse, DescribeReplicationSubnetGroupsError>;
fn describe_replication_task_assessment_results(
&self,
input: DescribeReplicationTaskAssessmentResultsMessage,
) -> RusotoFuture<
DescribeReplicationTaskAssessmentResultsResponse,
DescribeReplicationTaskAssessmentResultsError,
>;
fn describe_replication_tasks(
&self,
input: DescribeReplicationTasksMessage,
) -> RusotoFuture<DescribeReplicationTasksResponse, DescribeReplicationTasksError>;
fn describe_schemas(
&self,
input: DescribeSchemasMessage,
) -> RusotoFuture<DescribeSchemasResponse, DescribeSchemasError>;
fn describe_table_statistics(
&self,
input: DescribeTableStatisticsMessage,
) -> RusotoFuture<DescribeTableStatisticsResponse, DescribeTableStatisticsError>;
fn import_certificate(
&self,
input: ImportCertificateMessage,
) -> RusotoFuture<ImportCertificateResponse, ImportCertificateError>;
fn list_tags_for_resource(
&self,
input: ListTagsForResourceMessage,
) -> RusotoFuture<ListTagsForResourceResponse, ListTagsForResourceError>;
fn modify_endpoint(
&self,
input: ModifyEndpointMessage,
) -> RusotoFuture<ModifyEndpointResponse, ModifyEndpointError>;
fn modify_event_subscription(
&self,
input: ModifyEventSubscriptionMessage,
) -> RusotoFuture<ModifyEventSubscriptionResponse, ModifyEventSubscriptionError>;
fn modify_replication_instance(
&self,
input: ModifyReplicationInstanceMessage,
) -> RusotoFuture<ModifyReplicationInstanceResponse, ModifyReplicationInstanceError>;
fn modify_replication_subnet_group(
&self,
input: ModifyReplicationSubnetGroupMessage,
) -> RusotoFuture<ModifyReplicationSubnetGroupResponse, ModifyReplicationSubnetGroupError>;
fn modify_replication_task(
&self,
input: ModifyReplicationTaskMessage,
) -> RusotoFuture<ModifyReplicationTaskResponse, ModifyReplicationTaskError>;
fn reboot_replication_instance(
&self,
input: RebootReplicationInstanceMessage,
) -> RusotoFuture<RebootReplicationInstanceResponse, RebootReplicationInstanceError>;
fn refresh_schemas(
&self,
input: RefreshSchemasMessage,
) -> RusotoFuture<RefreshSchemasResponse, RefreshSchemasError>;
fn reload_tables(
&self,
input: ReloadTablesMessage,
) -> RusotoFuture<ReloadTablesResponse, ReloadTablesError>;
fn remove_tags_from_resource(
&self,
input: RemoveTagsFromResourceMessage,
) -> RusotoFuture<RemoveTagsFromResourceResponse, RemoveTagsFromResourceError>;
fn start_replication_task(
&self,
input: StartReplicationTaskMessage,
) -> RusotoFuture<StartReplicationTaskResponse, StartReplicationTaskError>;
fn start_replication_task_assessment(
&self,
input: StartReplicationTaskAssessmentMessage,
) -> RusotoFuture<StartReplicationTaskAssessmentResponse, StartReplicationTaskAssessmentError>;
fn stop_replication_task(
&self,
input: StopReplicationTaskMessage,
) -> RusotoFuture<StopReplicationTaskResponse, StopReplicationTaskError>;
fn test_connection(
&self,
input: TestConnectionMessage,
) -> RusotoFuture<TestConnectionResponse, TestConnectionError>;
}
pub struct DatabaseMigrationServiceClient {
client: Client,
region: region::Region,
}
impl DatabaseMigrationServiceClient {
pub fn new(region: region::Region) -> DatabaseMigrationServiceClient {
DatabaseMigrationServiceClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> DatabaseMigrationServiceClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
DatabaseMigrationServiceClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl DatabaseMigrationService for DatabaseMigrationServiceClient {
fn add_tags_to_resource(
&self,
input: AddTagsToResourceMessage,
) -> RusotoFuture<AddTagsToResourceResponse, AddTagsToResourceError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.AddTagsToResource");
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::<AddTagsToResourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(AddTagsToResourceError::from_response(response))),
)
}
})
}
fn create_endpoint(
&self,
input: CreateEndpointMessage,
) -> RusotoFuture<CreateEndpointResponse, CreateEndpointError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.CreateEndpoint");
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::<CreateEndpointResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateEndpointError::from_response(response))),
)
}
})
}
fn create_event_subscription(
&self,
input: CreateEventSubscriptionMessage,
) -> RusotoFuture<CreateEventSubscriptionResponse, CreateEventSubscriptionError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.CreateEventSubscription");
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::<CreateEventSubscriptionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateEventSubscriptionError::from_response(response))
}))
}
})
}
fn create_replication_instance(
&self,
input: CreateReplicationInstanceMessage,
) -> RusotoFuture<CreateReplicationInstanceResponse, CreateReplicationInstanceError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.CreateReplicationInstance",
);
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::<CreateReplicationInstanceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateReplicationInstanceError::from_response(response))
}))
}
})
}
fn create_replication_subnet_group(
&self,
input: CreateReplicationSubnetGroupMessage,
) -> RusotoFuture<CreateReplicationSubnetGroupResponse, CreateReplicationSubnetGroupError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.CreateReplicationSubnetGroup",
);
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::<CreateReplicationSubnetGroupResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateReplicationSubnetGroupError::from_response(response))
}))
}
})
}
fn create_replication_task(
&self,
input: CreateReplicationTaskMessage,
) -> RusotoFuture<CreateReplicationTaskResponse, CreateReplicationTaskError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.CreateReplicationTask");
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::<CreateReplicationTaskResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateReplicationTaskError::from_response(response))
}),
)
}
})
}
fn delete_certificate(
&self,
input: DeleteCertificateMessage,
) -> RusotoFuture<DeleteCertificateResponse, DeleteCertificateError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.DeleteCertificate");
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::<DeleteCertificateResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteCertificateError::from_response(response))),
)
}
})
}
fn delete_endpoint(
&self,
input: DeleteEndpointMessage,
) -> RusotoFuture<DeleteEndpointResponse, DeleteEndpointError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.DeleteEndpoint");
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::<DeleteEndpointResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteEndpointError::from_response(response))),
)
}
})
}
fn delete_event_subscription(
&self,
input: DeleteEventSubscriptionMessage,
) -> RusotoFuture<DeleteEventSubscriptionResponse, DeleteEventSubscriptionError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.DeleteEventSubscription");
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::<DeleteEventSubscriptionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteEventSubscriptionError::from_response(response))
}))
}
})
}
fn delete_replication_instance(
&self,
input: DeleteReplicationInstanceMessage,
) -> RusotoFuture<DeleteReplicationInstanceResponse, DeleteReplicationInstanceError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.DeleteReplicationInstance",
);
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::<DeleteReplicationInstanceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteReplicationInstanceError::from_response(response))
}))
}
})
}
fn delete_replication_subnet_group(
&self,
input: DeleteReplicationSubnetGroupMessage,
) -> RusotoFuture<DeleteReplicationSubnetGroupResponse, DeleteReplicationSubnetGroupError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.DeleteReplicationSubnetGroup",
);
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::<DeleteReplicationSubnetGroupResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteReplicationSubnetGroupError::from_response(response))
}))
}
})
}
fn delete_replication_task(
&self,
input: DeleteReplicationTaskMessage,
) -> RusotoFuture<DeleteReplicationTaskResponse, DeleteReplicationTaskError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.DeleteReplicationTask");
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::<DeleteReplicationTaskResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteReplicationTaskError::from_response(response))
}),
)
}
})
}
fn describe_account_attributes(
&self,
) -> RusotoFuture<DescribeAccountAttributesResponse, DescribeAccountAttributesError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.DescribeAccountAttributes",
);
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::<DescribeAccountAttributesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeAccountAttributesError::from_response(response))
}))
}
})
}
fn describe_certificates(
&self,
input: DescribeCertificatesMessage,
) -> RusotoFuture<DescribeCertificatesResponse, DescribeCertificatesError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.DescribeCertificates");
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::<DescribeCertificatesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeCertificatesError::from_response(response))
}),
)
}
})
}
fn describe_connections(
&self,
input: DescribeConnectionsMessage,
) -> RusotoFuture<DescribeConnectionsResponse, DescribeConnectionsError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.DescribeConnections");
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::<DescribeConnectionsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeConnectionsError::from_response(response))
}),
)
}
})
}
fn describe_endpoint_types(
&self,
input: DescribeEndpointTypesMessage,
) -> RusotoFuture<DescribeEndpointTypesResponse, DescribeEndpointTypesError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.DescribeEndpointTypes");
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::<DescribeEndpointTypesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeEndpointTypesError::from_response(response))
}),
)
}
})
}
fn describe_endpoints(
&self,
input: DescribeEndpointsMessage,
) -> RusotoFuture<DescribeEndpointsResponse, DescribeEndpointsError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.DescribeEndpoints");
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::<DescribeEndpointsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeEndpointsError::from_response(response))),
)
}
})
}
fn describe_event_categories(
&self,
input: DescribeEventCategoriesMessage,
) -> RusotoFuture<DescribeEventCategoriesResponse, DescribeEventCategoriesError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.DescribeEventCategories");
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::<DescribeEventCategoriesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeEventCategoriesError::from_response(response))
}))
}
})
}
fn describe_event_subscriptions(
&self,
input: DescribeEventSubscriptionsMessage,
) -> RusotoFuture<DescribeEventSubscriptionsResponse, DescribeEventSubscriptionsError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.DescribeEventSubscriptions",
);
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::<DescribeEventSubscriptionsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeEventSubscriptionsError::from_response(response))
}))
}
})
}
fn describe_events(
&self,
input: DescribeEventsMessage,
) -> RusotoFuture<DescribeEventsResponse, DescribeEventsError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.DescribeEvents");
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::<DescribeEventsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeEventsError::from_response(response))),
)
}
})
}
fn describe_orderable_replication_instances(
&self,
input: DescribeOrderableReplicationInstancesMessage,
) -> RusotoFuture<
DescribeOrderableReplicationInstancesResponse,
DescribeOrderableReplicationInstancesError,
> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.DescribeOrderableReplicationInstances",
);
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::<DescribeOrderableReplicationInstancesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeOrderableReplicationInstancesError::from_response(
response,
))
}))
}
})
}
fn describe_refresh_schemas_status(
&self,
input: DescribeRefreshSchemasStatusMessage,
) -> RusotoFuture<DescribeRefreshSchemasStatusResponse, DescribeRefreshSchemasStatusError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.DescribeRefreshSchemasStatus",
);
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::<DescribeRefreshSchemasStatusResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeRefreshSchemasStatusError::from_response(response))
}))
}
})
}
fn describe_replication_instance_task_logs(
&self,
input: DescribeReplicationInstanceTaskLogsMessage,
) -> RusotoFuture<
DescribeReplicationInstanceTaskLogsResponse,
DescribeReplicationInstanceTaskLogsError,
> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.DescribeReplicationInstanceTaskLogs",
);
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::<DescribeReplicationInstanceTaskLogsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeReplicationInstanceTaskLogsError::from_response(
response,
))
}))
}
})
}
fn describe_replication_instances(
&self,
input: DescribeReplicationInstancesMessage,
) -> RusotoFuture<DescribeReplicationInstancesResponse, DescribeReplicationInstancesError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.DescribeReplicationInstances",
);
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::<DescribeReplicationInstancesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeReplicationInstancesError::from_response(response))
}))
}
})
}
fn describe_replication_subnet_groups(
&self,
input: DescribeReplicationSubnetGroupsMessage,
) -> RusotoFuture<DescribeReplicationSubnetGroupsResponse, DescribeReplicationSubnetGroupsError>
{
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.DescribeReplicationSubnetGroups",
);
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::<DescribeReplicationSubnetGroupsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeReplicationSubnetGroupsError::from_response(
response,
))
}))
}
})
}
fn describe_replication_task_assessment_results(
&self,
input: DescribeReplicationTaskAssessmentResultsMessage,
) -> RusotoFuture<
DescribeReplicationTaskAssessmentResultsResponse,
DescribeReplicationTaskAssessmentResultsError,
> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.DescribeReplicationTaskAssessmentResults",
);
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::<DescribeReplicationTaskAssessmentResultsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeReplicationTaskAssessmentResultsError::from_response(response))
}))
}
})
}
fn describe_replication_tasks(
&self,
input: DescribeReplicationTasksMessage,
) -> RusotoFuture<DescribeReplicationTasksResponse, DescribeReplicationTasksError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.DescribeReplicationTasks",
);
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::<DescribeReplicationTasksResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeReplicationTasksError::from_response(response))
}))
}
})
}
fn describe_schemas(
&self,
input: DescribeSchemasMessage,
) -> RusotoFuture<DescribeSchemasResponse, DescribeSchemasError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.DescribeSchemas");
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::<DescribeSchemasResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeSchemasError::from_response(response))),
)
}
})
}
fn describe_table_statistics(
&self,
input: DescribeTableStatisticsMessage,
) -> RusotoFuture<DescribeTableStatisticsResponse, DescribeTableStatisticsError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.DescribeTableStatistics");
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::<DescribeTableStatisticsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeTableStatisticsError::from_response(response))
}))
}
})
}
fn import_certificate(
&self,
input: ImportCertificateMessage,
) -> RusotoFuture<ImportCertificateResponse, ImportCertificateError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.ImportCertificate");
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::<ImportCertificateResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ImportCertificateError::from_response(response))),
)
}
})
}
fn list_tags_for_resource(
&self,
input: ListTagsForResourceMessage,
) -> RusotoFuture<ListTagsForResourceResponse, ListTagsForResourceError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.ListTagsForResource");
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::<ListTagsForResourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListTagsForResourceError::from_response(response))
}),
)
}
})
}
fn modify_endpoint(
&self,
input: ModifyEndpointMessage,
) -> RusotoFuture<ModifyEndpointResponse, ModifyEndpointError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.ModifyEndpoint");
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::<ModifyEndpointResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ModifyEndpointError::from_response(response))),
)
}
})
}
fn modify_event_subscription(
&self,
input: ModifyEventSubscriptionMessage,
) -> RusotoFuture<ModifyEventSubscriptionResponse, ModifyEventSubscriptionError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.ModifyEventSubscription");
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::<ModifyEventSubscriptionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyEventSubscriptionError::from_response(response))
}))
}
})
}
fn modify_replication_instance(
&self,
input: ModifyReplicationInstanceMessage,
) -> RusotoFuture<ModifyReplicationInstanceResponse, ModifyReplicationInstanceError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.ModifyReplicationInstance",
);
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::<ModifyReplicationInstanceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyReplicationInstanceError::from_response(response))
}))
}
})
}
fn modify_replication_subnet_group(
&self,
input: ModifyReplicationSubnetGroupMessage,
) -> RusotoFuture<ModifyReplicationSubnetGroupResponse, ModifyReplicationSubnetGroupError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.ModifyReplicationSubnetGroup",
);
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::<ModifyReplicationSubnetGroupResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ModifyReplicationSubnetGroupError::from_response(response))
}))
}
})
}
fn modify_replication_task(
&self,
input: ModifyReplicationTaskMessage,
) -> RusotoFuture<ModifyReplicationTaskResponse, ModifyReplicationTaskError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.ModifyReplicationTask");
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::<ModifyReplicationTaskResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ModifyReplicationTaskError::from_response(response))
}),
)
}
})
}
fn reboot_replication_instance(
&self,
input: RebootReplicationInstanceMessage,
) -> RusotoFuture<RebootReplicationInstanceResponse, RebootReplicationInstanceError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.RebootReplicationInstance",
);
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::<RebootReplicationInstanceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(RebootReplicationInstanceError::from_response(response))
}))
}
})
}
fn refresh_schemas(
&self,
input: RefreshSchemasMessage,
) -> RusotoFuture<RefreshSchemasResponse, RefreshSchemasError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.RefreshSchemas");
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::<RefreshSchemasResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RefreshSchemasError::from_response(response))),
)
}
})
}
fn reload_tables(
&self,
input: ReloadTablesMessage,
) -> RusotoFuture<ReloadTablesResponse, ReloadTablesError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.ReloadTables");
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::<ReloadTablesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ReloadTablesError::from_response(response))),
)
}
})
}
fn remove_tags_from_resource(
&self,
input: RemoveTagsFromResourceMessage,
) -> RusotoFuture<RemoveTagsFromResourceResponse, RemoveTagsFromResourceError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.RemoveTagsFromResource");
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::<RemoveTagsFromResourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(RemoveTagsFromResourceError::from_response(response))
}),
)
}
})
}
fn start_replication_task(
&self,
input: StartReplicationTaskMessage,
) -> RusotoFuture<StartReplicationTaskResponse, StartReplicationTaskError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.StartReplicationTask");
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::<StartReplicationTaskResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(StartReplicationTaskError::from_response(response))
}),
)
}
})
}
fn start_replication_task_assessment(
&self,
input: StartReplicationTaskAssessmentMessage,
) -> RusotoFuture<StartReplicationTaskAssessmentResponse, StartReplicationTaskAssessmentError>
{
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonDMSv20160101.StartReplicationTaskAssessment",
);
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::<StartReplicationTaskAssessmentResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(StartReplicationTaskAssessmentError::from_response(response))
}))
}
})
}
fn stop_replication_task(
&self,
input: StopReplicationTaskMessage,
) -> RusotoFuture<StopReplicationTaskResponse, StopReplicationTaskError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.StopReplicationTask");
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::<StopReplicationTaskResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(StopReplicationTaskError::from_response(response))
}),
)
}
})
}
fn test_connection(
&self,
input: TestConnectionMessage,
) -> RusotoFuture<TestConnectionResponse, TestConnectionError> {
let mut request = SignedRequest::new("POST", "dms", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AmazonDMSv20160101.TestConnection");
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::<TestConnectionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(TestConnectionError::from_response(response))),
)
}
})
}
}
#[cfg(test)]
mod protocol_tests {}