use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl GlobalAcceleratorClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request =
SignedRequest::new(http_method, "globalaccelerator", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Accelerator {
#[serde(rename = "AcceleratorArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator_arn: Option<String>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "DnsName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dns_name: Option<String>,
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "IpAddressType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address_type: Option<String>,
#[serde(rename = "IpSets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_sets: Option<Vec<IpSet>>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AcceleratorAttributes {
#[serde(rename = "FlowLogsEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_logs_enabled: Option<bool>,
#[serde(rename = "FlowLogsS3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_logs_s3_bucket: Option<String>,
#[serde(rename = "FlowLogsS3Prefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_logs_s3_prefix: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddCustomRoutingEndpointsRequest {
#[serde(rename = "EndpointConfigurations")]
pub endpoint_configurations: Vec<CustomRoutingEndpointConfiguration>,
#[serde(rename = "EndpointGroupArn")]
pub endpoint_group_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddCustomRoutingEndpointsResponse {
#[serde(rename = "EndpointDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_descriptions: Option<Vec<CustomRoutingEndpointDescription>>,
#[serde(rename = "EndpointGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdvertiseByoipCidrRequest {
#[serde(rename = "Cidr")]
pub cidr: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdvertiseByoipCidrResponse {
#[serde(rename = "ByoipCidr")]
#[serde(skip_serializing_if = "Option::is_none")]
pub byoip_cidr: Option<ByoipCidr>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AllowCustomRoutingTrafficRequest {
#[serde(rename = "AllowAllTrafficToEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_all_traffic_to_endpoint: Option<bool>,
#[serde(rename = "DestinationAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_addresses: Option<Vec<String>>,
#[serde(rename = "DestinationPorts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_ports: Option<Vec<i64>>,
#[serde(rename = "EndpointGroupArn")]
pub endpoint_group_arn: String,
#[serde(rename = "EndpointId")]
pub endpoint_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ByoipCidr {
#[serde(rename = "Cidr")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cidr: Option<String>,
#[serde(rename = "Events")]
#[serde(skip_serializing_if = "Option::is_none")]
pub events: Option<Vec<ByoipCidrEvent>>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ByoipCidrEvent {
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "Timestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timestamp: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CidrAuthorizationContext {
#[serde(rename = "Message")]
pub message: String,
#[serde(rename = "Signature")]
pub signature: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateAcceleratorRequest {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "IpAddressType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address_type: Option<String>,
#[serde(rename = "IpAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_addresses: Option<Vec<String>>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateAcceleratorResponse {
#[serde(rename = "Accelerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator: Option<Accelerator>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCustomRoutingAcceleratorRequest {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "IpAddressType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address_type: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCustomRoutingAcceleratorResponse {
#[serde(rename = "Accelerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator: Option<CustomRoutingAccelerator>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCustomRoutingEndpointGroupRequest {
#[serde(rename = "DestinationConfigurations")]
pub destination_configurations: Vec<CustomRoutingDestinationConfiguration>,
#[serde(rename = "EndpointGroupRegion")]
pub endpoint_group_region: String,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "ListenerArn")]
pub listener_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCustomRoutingEndpointGroupResponse {
#[serde(rename = "EndpointGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group: Option<CustomRoutingEndpointGroup>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCustomRoutingListenerRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "PortRanges")]
pub port_ranges: Vec<PortRange>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCustomRoutingListenerResponse {
#[serde(rename = "Listener")]
#[serde(skip_serializing_if = "Option::is_none")]
pub listener: Option<CustomRoutingListener>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateEndpointGroupRequest {
#[serde(rename = "EndpointConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_configurations: Option<Vec<EndpointConfiguration>>,
#[serde(rename = "EndpointGroupRegion")]
pub endpoint_group_region: String,
#[serde(rename = "HealthCheckIntervalSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_interval_seconds: Option<i64>,
#[serde(rename = "HealthCheckPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_path: Option<String>,
#[serde(rename = "HealthCheckPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_port: Option<i64>,
#[serde(rename = "HealthCheckProtocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_protocol: Option<String>,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "ListenerArn")]
pub listener_arn: String,
#[serde(rename = "PortOverrides")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_overrides: Option<Vec<PortOverride>>,
#[serde(rename = "ThresholdCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub threshold_count: Option<i64>,
#[serde(rename = "TrafficDialPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub traffic_dial_percentage: Option<f32>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateEndpointGroupResponse {
#[serde(rename = "EndpointGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group: Option<EndpointGroup>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateListenerRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
#[serde(rename = "ClientAffinity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_affinity: Option<String>,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "PortRanges")]
pub port_ranges: Vec<PortRange>,
#[serde(rename = "Protocol")]
pub protocol: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateListenerResponse {
#[serde(rename = "Listener")]
#[serde(skip_serializing_if = "Option::is_none")]
pub listener: Option<Listener>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CustomRoutingAccelerator {
#[serde(rename = "AcceleratorArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator_arn: Option<String>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "DnsName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dns_name: Option<String>,
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "IpAddressType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address_type: Option<String>,
#[serde(rename = "IpSets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_sets: Option<Vec<IpSet>>,
#[serde(rename = "LastModifiedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_time: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CustomRoutingAcceleratorAttributes {
#[serde(rename = "FlowLogsEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_logs_enabled: Option<bool>,
#[serde(rename = "FlowLogsS3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_logs_s3_bucket: Option<String>,
#[serde(rename = "FlowLogsS3Prefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_logs_s3_prefix: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CustomRoutingDestinationConfiguration {
#[serde(rename = "FromPort")]
pub from_port: i64,
#[serde(rename = "Protocols")]
pub protocols: Vec<String>,
#[serde(rename = "ToPort")]
pub to_port: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CustomRoutingDestinationDescription {
#[serde(rename = "FromPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_port: Option<i64>,
#[serde(rename = "Protocols")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocols: Option<Vec<String>>,
#[serde(rename = "ToPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub to_port: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CustomRoutingEndpointConfiguration {
#[serde(rename = "EndpointId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CustomRoutingEndpointDescription {
#[serde(rename = "EndpointId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CustomRoutingEndpointGroup {
#[serde(rename = "DestinationDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_descriptions: Option<Vec<CustomRoutingDestinationDescription>>,
#[serde(rename = "EndpointDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_descriptions: Option<Vec<CustomRoutingEndpointDescription>>,
#[serde(rename = "EndpointGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group_arn: Option<String>,
#[serde(rename = "EndpointGroupRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group_region: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CustomRoutingListener {
#[serde(rename = "ListenerArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub listener_arn: Option<String>,
#[serde(rename = "PortRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_ranges: Option<Vec<PortRange>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAcceleratorRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCustomRoutingAcceleratorRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCustomRoutingEndpointGroupRequest {
#[serde(rename = "EndpointGroupArn")]
pub endpoint_group_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCustomRoutingListenerRequest {
#[serde(rename = "ListenerArn")]
pub listener_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteEndpointGroupRequest {
#[serde(rename = "EndpointGroupArn")]
pub endpoint_group_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteListenerRequest {
#[serde(rename = "ListenerArn")]
pub listener_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DenyCustomRoutingTrafficRequest {
#[serde(rename = "DenyAllTrafficToEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deny_all_traffic_to_endpoint: Option<bool>,
#[serde(rename = "DestinationAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_addresses: Option<Vec<String>>,
#[serde(rename = "DestinationPorts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_ports: Option<Vec<i64>>,
#[serde(rename = "EndpointGroupArn")]
pub endpoint_group_arn: String,
#[serde(rename = "EndpointId")]
pub endpoint_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeprovisionByoipCidrRequest {
#[serde(rename = "Cidr")]
pub cidr: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeprovisionByoipCidrResponse {
#[serde(rename = "ByoipCidr")]
#[serde(skip_serializing_if = "Option::is_none")]
pub byoip_cidr: Option<ByoipCidr>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAcceleratorAttributesRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAcceleratorAttributesResponse {
#[serde(rename = "AcceleratorAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator_attributes: Option<AcceleratorAttributes>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAcceleratorRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAcceleratorResponse {
#[serde(rename = "Accelerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator: Option<Accelerator>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCustomRoutingAcceleratorAttributesRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCustomRoutingAcceleratorAttributesResponse {
#[serde(rename = "AcceleratorAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator_attributes: Option<CustomRoutingAcceleratorAttributes>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCustomRoutingAcceleratorRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCustomRoutingAcceleratorResponse {
#[serde(rename = "Accelerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator: Option<CustomRoutingAccelerator>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCustomRoutingEndpointGroupRequest {
#[serde(rename = "EndpointGroupArn")]
pub endpoint_group_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCustomRoutingEndpointGroupResponse {
#[serde(rename = "EndpointGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group: Option<CustomRoutingEndpointGroup>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCustomRoutingListenerRequest {
#[serde(rename = "ListenerArn")]
pub listener_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCustomRoutingListenerResponse {
#[serde(rename = "Listener")]
#[serde(skip_serializing_if = "Option::is_none")]
pub listener: Option<CustomRoutingListener>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEndpointGroupRequest {
#[serde(rename = "EndpointGroupArn")]
pub endpoint_group_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeEndpointGroupResponse {
#[serde(rename = "EndpointGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group: Option<EndpointGroup>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeListenerRequest {
#[serde(rename = "ListenerArn")]
pub listener_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeListenerResponse {
#[serde(rename = "Listener")]
#[serde(skip_serializing_if = "Option::is_none")]
pub listener: Option<Listener>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DestinationPortMapping {
#[serde(rename = "AcceleratorArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator_arn: Option<String>,
#[serde(rename = "AcceleratorSocketAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator_socket_addresses: Option<Vec<SocketAddress>>,
#[serde(rename = "DestinationSocketAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_socket_address: Option<SocketAddress>,
#[serde(rename = "DestinationTrafficState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_traffic_state: Option<String>,
#[serde(rename = "EndpointGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group_arn: Option<String>,
#[serde(rename = "EndpointGroupRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group_region: Option<String>,
#[serde(rename = "EndpointId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_id: Option<String>,
#[serde(rename = "IpAddressType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EndpointConfiguration {
#[serde(rename = "ClientIPPreservationEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_ip_preservation_enabled: Option<bool>,
#[serde(rename = "EndpointId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_id: Option<String>,
#[serde(rename = "Weight")]
#[serde(skip_serializing_if = "Option::is_none")]
pub weight: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EndpointDescription {
#[serde(rename = "ClientIPPreservationEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_ip_preservation_enabled: Option<bool>,
#[serde(rename = "EndpointId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_id: Option<String>,
#[serde(rename = "HealthReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_reason: Option<String>,
#[serde(rename = "HealthState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_state: Option<String>,
#[serde(rename = "Weight")]
#[serde(skip_serializing_if = "Option::is_none")]
pub weight: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EndpointGroup {
#[serde(rename = "EndpointDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_descriptions: Option<Vec<EndpointDescription>>,
#[serde(rename = "EndpointGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group_arn: Option<String>,
#[serde(rename = "EndpointGroupRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group_region: Option<String>,
#[serde(rename = "HealthCheckIntervalSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_interval_seconds: Option<i64>,
#[serde(rename = "HealthCheckPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_path: Option<String>,
#[serde(rename = "HealthCheckPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_port: Option<i64>,
#[serde(rename = "HealthCheckProtocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_protocol: Option<String>,
#[serde(rename = "PortOverrides")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_overrides: Option<Vec<PortOverride>>,
#[serde(rename = "ThresholdCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub threshold_count: Option<i64>,
#[serde(rename = "TrafficDialPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub traffic_dial_percentage: Option<f32>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IpSet {
#[serde(rename = "IpAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_addresses: Option<Vec<String>>,
#[serde(rename = "IpFamily")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_family: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAcceleratorsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAcceleratorsResponse {
#[serde(rename = "Accelerators")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerators: Option<Vec<Accelerator>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListByoipCidrsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListByoipCidrsResponse {
#[serde(rename = "ByoipCidrs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub byoip_cidrs: Option<Vec<ByoipCidr>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCustomRoutingAcceleratorsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListCustomRoutingAcceleratorsResponse {
#[serde(rename = "Accelerators")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerators: Option<Vec<CustomRoutingAccelerator>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCustomRoutingEndpointGroupsRequest {
#[serde(rename = "ListenerArn")]
pub listener_arn: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListCustomRoutingEndpointGroupsResponse {
#[serde(rename = "EndpointGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_groups: Option<Vec<CustomRoutingEndpointGroup>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCustomRoutingListenersRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListCustomRoutingListenersResponse {
#[serde(rename = "Listeners")]
#[serde(skip_serializing_if = "Option::is_none")]
pub listeners: Option<Vec<CustomRoutingListener>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCustomRoutingPortMappingsByDestinationRequest {
#[serde(rename = "DestinationAddress")]
pub destination_address: String,
#[serde(rename = "EndpointId")]
pub endpoint_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListCustomRoutingPortMappingsByDestinationResponse {
#[serde(rename = "DestinationPortMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_port_mappings: Option<Vec<DestinationPortMapping>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCustomRoutingPortMappingsRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
#[serde(rename = "EndpointGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group_arn: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListCustomRoutingPortMappingsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PortMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_mappings: Option<Vec<PortMapping>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListEndpointGroupsRequest {
#[serde(rename = "ListenerArn")]
pub listener_arn: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListEndpointGroupsResponse {
#[serde(rename = "EndpointGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_groups: Option<Vec<EndpointGroup>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListListenersRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListListenersResponse {
#[serde(rename = "Listeners")]
#[serde(skip_serializing_if = "Option::is_none")]
pub listeners: Option<Vec<Listener>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Listener {
#[serde(rename = "ClientAffinity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_affinity: Option<String>,
#[serde(rename = "ListenerArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub listener_arn: Option<String>,
#[serde(rename = "PortRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_ranges: Option<Vec<PortRange>>,
#[serde(rename = "Protocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PortMapping {
#[serde(rename = "AcceleratorPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator_port: Option<i64>,
#[serde(rename = "DestinationSocketAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_socket_address: Option<SocketAddress>,
#[serde(rename = "DestinationTrafficState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_traffic_state: Option<String>,
#[serde(rename = "EndpointGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group_arn: Option<String>,
#[serde(rename = "EndpointId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_id: Option<String>,
#[serde(rename = "Protocols")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocols: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct PortOverride {
#[serde(rename = "EndpointPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_port: Option<i64>,
#[serde(rename = "ListenerPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub listener_port: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct PortRange {
#[serde(rename = "FromPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from_port: Option<i64>,
#[serde(rename = "ToPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub to_port: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ProvisionByoipCidrRequest {
#[serde(rename = "Cidr")]
pub cidr: String,
#[serde(rename = "CidrAuthorizationContext")]
pub cidr_authorization_context: CidrAuthorizationContext,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProvisionByoipCidrResponse {
#[serde(rename = "ByoipCidr")]
#[serde(skip_serializing_if = "Option::is_none")]
pub byoip_cidr: Option<ByoipCidr>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemoveCustomRoutingEndpointsRequest {
#[serde(rename = "EndpointGroupArn")]
pub endpoint_group_arn: String,
#[serde(rename = "EndpointIds")]
pub endpoint_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SocketAddress {
#[serde(rename = "IpAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address: Option<String>,
#[serde(rename = "Port")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateAcceleratorAttributesRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
#[serde(rename = "FlowLogsEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_logs_enabled: Option<bool>,
#[serde(rename = "FlowLogsS3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_logs_s3_bucket: Option<String>,
#[serde(rename = "FlowLogsS3Prefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_logs_s3_prefix: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateAcceleratorAttributesResponse {
#[serde(rename = "AcceleratorAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator_attributes: Option<AcceleratorAttributes>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateAcceleratorRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "IpAddressType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address_type: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateAcceleratorResponse {
#[serde(rename = "Accelerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator: Option<Accelerator>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateCustomRoutingAcceleratorAttributesRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
#[serde(rename = "FlowLogsEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_logs_enabled: Option<bool>,
#[serde(rename = "FlowLogsS3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_logs_s3_bucket: Option<String>,
#[serde(rename = "FlowLogsS3Prefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_logs_s3_prefix: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateCustomRoutingAcceleratorAttributesResponse {
#[serde(rename = "AcceleratorAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator_attributes: Option<CustomRoutingAcceleratorAttributes>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateCustomRoutingAcceleratorRequest {
#[serde(rename = "AcceleratorArn")]
pub accelerator_arn: String,
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "IpAddressType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address_type: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateCustomRoutingAcceleratorResponse {
#[serde(rename = "Accelerator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accelerator: Option<CustomRoutingAccelerator>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateCustomRoutingListenerRequest {
#[serde(rename = "ListenerArn")]
pub listener_arn: String,
#[serde(rename = "PortRanges")]
pub port_ranges: Vec<PortRange>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateCustomRoutingListenerResponse {
#[serde(rename = "Listener")]
#[serde(skip_serializing_if = "Option::is_none")]
pub listener: Option<CustomRoutingListener>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateEndpointGroupRequest {
#[serde(rename = "EndpointConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_configurations: Option<Vec<EndpointConfiguration>>,
#[serde(rename = "EndpointGroupArn")]
pub endpoint_group_arn: String,
#[serde(rename = "HealthCheckIntervalSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_interval_seconds: Option<i64>,
#[serde(rename = "HealthCheckPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_path: Option<String>,
#[serde(rename = "HealthCheckPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_port: Option<i64>,
#[serde(rename = "HealthCheckProtocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_protocol: Option<String>,
#[serde(rename = "PortOverrides")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_overrides: Option<Vec<PortOverride>>,
#[serde(rename = "ThresholdCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub threshold_count: Option<i64>,
#[serde(rename = "TrafficDialPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub traffic_dial_percentage: Option<f32>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateEndpointGroupResponse {
#[serde(rename = "EndpointGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_group: Option<EndpointGroup>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateListenerRequest {
#[serde(rename = "ClientAffinity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_affinity: Option<String>,
#[serde(rename = "ListenerArn")]
pub listener_arn: String,
#[serde(rename = "PortRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_ranges: Option<Vec<PortRange>>,
#[serde(rename = "Protocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateListenerResponse {
#[serde(rename = "Listener")]
#[serde(skip_serializing_if = "Option::is_none")]
pub listener: Option<Listener>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct WithdrawByoipCidrRequest {
#[serde(rename = "Cidr")]
pub cidr: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WithdrawByoipCidrResponse {
#[serde(rename = "ByoipCidr")]
#[serde(skip_serializing_if = "Option::is_none")]
pub byoip_cidr: Option<ByoipCidr>,
}
#[derive(Debug, PartialEq)]
pub enum AddCustomRoutingEndpointsError {
AccessDenied(String),
Conflict(String),
EndpointAlreadyExists(String),
EndpointGroupNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
LimitExceeded(String),
}
impl AddCustomRoutingEndpointsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddCustomRoutingEndpointsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AddCustomRoutingEndpointsError::AccessDenied(
err.msg,
))
}
"ConflictException" => {
return RusotoError::Service(AddCustomRoutingEndpointsError::Conflict(err.msg))
}
"EndpointAlreadyExistsException" => {
return RusotoError::Service(
AddCustomRoutingEndpointsError::EndpointAlreadyExists(err.msg),
)
}
"EndpointGroupNotFoundException" => {
return RusotoError::Service(
AddCustomRoutingEndpointsError::EndpointGroupNotFound(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
AddCustomRoutingEndpointsError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(AddCustomRoutingEndpointsError::InvalidArgument(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(AddCustomRoutingEndpointsError::LimitExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddCustomRoutingEndpointsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddCustomRoutingEndpointsError::AccessDenied(ref cause) => write!(f, "{}", cause),
AddCustomRoutingEndpointsError::Conflict(ref cause) => write!(f, "{}", cause),
AddCustomRoutingEndpointsError::EndpointAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
AddCustomRoutingEndpointsError::EndpointGroupNotFound(ref cause) => {
write!(f, "{}", cause)
}
AddCustomRoutingEndpointsError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
AddCustomRoutingEndpointsError::InvalidArgument(ref cause) => write!(f, "{}", cause),
AddCustomRoutingEndpointsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddCustomRoutingEndpointsError {}
#[derive(Debug, PartialEq)]
pub enum AdvertiseByoipCidrError {
AccessDenied(String),
ByoipCidrNotFound(String),
IncorrectCidrState(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl AdvertiseByoipCidrError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdvertiseByoipCidrError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AdvertiseByoipCidrError::AccessDenied(err.msg))
}
"ByoipCidrNotFoundException" => {
return RusotoError::Service(AdvertiseByoipCidrError::ByoipCidrNotFound(
err.msg,
))
}
"IncorrectCidrStateException" => {
return RusotoError::Service(AdvertiseByoipCidrError::IncorrectCidrState(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(AdvertiseByoipCidrError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(AdvertiseByoipCidrError::InvalidArgument(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdvertiseByoipCidrError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdvertiseByoipCidrError::AccessDenied(ref cause) => write!(f, "{}", cause),
AdvertiseByoipCidrError::ByoipCidrNotFound(ref cause) => write!(f, "{}", cause),
AdvertiseByoipCidrError::IncorrectCidrState(ref cause) => write!(f, "{}", cause),
AdvertiseByoipCidrError::InternalServiceError(ref cause) => write!(f, "{}", cause),
AdvertiseByoipCidrError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdvertiseByoipCidrError {}
#[derive(Debug, PartialEq)]
pub enum AllowCustomRoutingTrafficError {
InternalServiceError(String),
InvalidArgument(String),
}
impl AllowCustomRoutingTrafficError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AllowCustomRoutingTrafficError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(
AllowCustomRoutingTrafficError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(AllowCustomRoutingTrafficError::InvalidArgument(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AllowCustomRoutingTrafficError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AllowCustomRoutingTrafficError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
AllowCustomRoutingTrafficError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AllowCustomRoutingTrafficError {}
#[derive(Debug, PartialEq)]
pub enum CreateAcceleratorError {
InternalServiceError(String),
InvalidArgument(String),
LimitExceeded(String),
}
impl CreateAcceleratorError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateAcceleratorError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(CreateAcceleratorError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(CreateAcceleratorError::InvalidArgument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateAcceleratorError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateAcceleratorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateAcceleratorError::InternalServiceError(ref cause) => write!(f, "{}", cause),
CreateAcceleratorError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreateAcceleratorError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateAcceleratorError {}
#[derive(Debug, PartialEq)]
pub enum CreateCustomRoutingAcceleratorError {
AccessDenied(String),
InternalServiceError(String),
InvalidArgument(String),
LimitExceeded(String),
}
impl CreateCustomRoutingAcceleratorError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateCustomRoutingAcceleratorError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateCustomRoutingAcceleratorError::AccessDenied(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(
CreateCustomRoutingAcceleratorError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
CreateCustomRoutingAcceleratorError::InvalidArgument(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
CreateCustomRoutingAcceleratorError::LimitExceeded(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateCustomRoutingAcceleratorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCustomRoutingAcceleratorError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateCustomRoutingAcceleratorError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
CreateCustomRoutingAcceleratorError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
CreateCustomRoutingAcceleratorError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateCustomRoutingAcceleratorError {}
#[derive(Debug, PartialEq)]
pub enum CreateCustomRoutingEndpointGroupError {
AcceleratorNotFound(String),
AccessDenied(String),
EndpointGroupAlreadyExists(String),
InternalServiceError(String),
InvalidArgument(String),
InvalidPortRange(String),
LimitExceeded(String),
ListenerNotFound(String),
}
impl CreateCustomRoutingEndpointGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateCustomRoutingEndpointGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(
CreateCustomRoutingEndpointGroupError::AcceleratorNotFound(err.msg),
)
}
"AccessDeniedException" => {
return RusotoError::Service(
CreateCustomRoutingEndpointGroupError::AccessDenied(err.msg),
)
}
"EndpointGroupAlreadyExistsException" => {
return RusotoError::Service(
CreateCustomRoutingEndpointGroupError::EndpointGroupAlreadyExists(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
CreateCustomRoutingEndpointGroupError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
CreateCustomRoutingEndpointGroupError::InvalidArgument(err.msg),
)
}
"InvalidPortRangeException" => {
return RusotoError::Service(
CreateCustomRoutingEndpointGroupError::InvalidPortRange(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
CreateCustomRoutingEndpointGroupError::LimitExceeded(err.msg),
)
}
"ListenerNotFoundException" => {
return RusotoError::Service(
CreateCustomRoutingEndpointGroupError::ListenerNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateCustomRoutingEndpointGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCustomRoutingEndpointGroupError::AcceleratorNotFound(ref cause) => {
write!(f, "{}", cause)
}
CreateCustomRoutingEndpointGroupError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
CreateCustomRoutingEndpointGroupError::EndpointGroupAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateCustomRoutingEndpointGroupError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
CreateCustomRoutingEndpointGroupError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
CreateCustomRoutingEndpointGroupError::InvalidPortRange(ref cause) => {
write!(f, "{}", cause)
}
CreateCustomRoutingEndpointGroupError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateCustomRoutingEndpointGroupError::ListenerNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateCustomRoutingEndpointGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateCustomRoutingListenerError {
AcceleratorNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
InvalidPortRange(String),
LimitExceeded(String),
}
impl CreateCustomRoutingListenerError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateCustomRoutingListenerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(
CreateCustomRoutingListenerError::AcceleratorNotFound(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
CreateCustomRoutingListenerError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(CreateCustomRoutingListenerError::InvalidArgument(
err.msg,
))
}
"InvalidPortRangeException" => {
return RusotoError::Service(
CreateCustomRoutingListenerError::InvalidPortRange(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(CreateCustomRoutingListenerError::LimitExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateCustomRoutingListenerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCustomRoutingListenerError::AcceleratorNotFound(ref cause) => {
write!(f, "{}", cause)
}
CreateCustomRoutingListenerError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
CreateCustomRoutingListenerError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreateCustomRoutingListenerError::InvalidPortRange(ref cause) => write!(f, "{}", cause),
CreateCustomRoutingListenerError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateCustomRoutingListenerError {}
#[derive(Debug, PartialEq)]
pub enum CreateEndpointGroupError {
AcceleratorNotFound(String),
AccessDenied(String),
EndpointGroupAlreadyExists(String),
InternalServiceError(String),
InvalidArgument(String),
LimitExceeded(String),
ListenerNotFound(String),
}
impl CreateEndpointGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateEndpointGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(CreateEndpointGroupError::AcceleratorNotFound(
err.msg,
))
}
"AccessDeniedException" => {
return RusotoError::Service(CreateEndpointGroupError::AccessDenied(err.msg))
}
"EndpointGroupAlreadyExistsException" => {
return RusotoError::Service(
CreateEndpointGroupError::EndpointGroupAlreadyExists(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(CreateEndpointGroupError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(CreateEndpointGroupError::InvalidArgument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateEndpointGroupError::LimitExceeded(err.msg))
}
"ListenerNotFoundException" => {
return RusotoError::Service(CreateEndpointGroupError::ListenerNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateEndpointGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateEndpointGroupError::AcceleratorNotFound(ref cause) => write!(f, "{}", cause),
CreateEndpointGroupError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateEndpointGroupError::EndpointGroupAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateEndpointGroupError::InternalServiceError(ref cause) => write!(f, "{}", cause),
CreateEndpointGroupError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreateEndpointGroupError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateEndpointGroupError::ListenerNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateEndpointGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateListenerError {
AcceleratorNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
InvalidPortRange(String),
LimitExceeded(String),
}
impl CreateListenerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateListenerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(CreateListenerError::AcceleratorNotFound(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(CreateListenerError::InternalServiceError(err.msg))
}
"InvalidArgumentException" => {
return RusotoError::Service(CreateListenerError::InvalidArgument(err.msg))
}
"InvalidPortRangeException" => {
return RusotoError::Service(CreateListenerError::InvalidPortRange(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateListenerError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateListenerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateListenerError::AcceleratorNotFound(ref cause) => write!(f, "{}", cause),
CreateListenerError::InternalServiceError(ref cause) => write!(f, "{}", cause),
CreateListenerError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreateListenerError::InvalidPortRange(ref cause) => write!(f, "{}", cause),
CreateListenerError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateListenerError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAcceleratorError {
AcceleratorNotDisabled(String),
AcceleratorNotFound(String),
AssociatedListenerFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl DeleteAcceleratorError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAcceleratorError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotDisabledException" => {
return RusotoError::Service(DeleteAcceleratorError::AcceleratorNotDisabled(
err.msg,
))
}
"AcceleratorNotFoundException" => {
return RusotoError::Service(DeleteAcceleratorError::AcceleratorNotFound(
err.msg,
))
}
"AssociatedListenerFoundException" => {
return RusotoError::Service(DeleteAcceleratorError::AssociatedListenerFound(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(DeleteAcceleratorError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(DeleteAcceleratorError::InvalidArgument(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAcceleratorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAcceleratorError::AcceleratorNotDisabled(ref cause) => write!(f, "{}", cause),
DeleteAcceleratorError::AcceleratorNotFound(ref cause) => write!(f, "{}", cause),
DeleteAcceleratorError::AssociatedListenerFound(ref cause) => write!(f, "{}", cause),
DeleteAcceleratorError::InternalServiceError(ref cause) => write!(f, "{}", cause),
DeleteAcceleratorError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteAcceleratorError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCustomRoutingAcceleratorError {
AcceleratorNotDisabled(String),
AcceleratorNotFound(String),
AssociatedListenerFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl DeleteCustomRoutingAcceleratorError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteCustomRoutingAcceleratorError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotDisabledException" => {
return RusotoError::Service(
DeleteCustomRoutingAcceleratorError::AcceleratorNotDisabled(err.msg),
)
}
"AcceleratorNotFoundException" => {
return RusotoError::Service(
DeleteCustomRoutingAcceleratorError::AcceleratorNotFound(err.msg),
)
}
"AssociatedListenerFoundException" => {
return RusotoError::Service(
DeleteCustomRoutingAcceleratorError::AssociatedListenerFound(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
DeleteCustomRoutingAcceleratorError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
DeleteCustomRoutingAcceleratorError::InvalidArgument(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteCustomRoutingAcceleratorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCustomRoutingAcceleratorError::AcceleratorNotDisabled(ref cause) => {
write!(f, "{}", cause)
}
DeleteCustomRoutingAcceleratorError::AcceleratorNotFound(ref cause) => {
write!(f, "{}", cause)
}
DeleteCustomRoutingAcceleratorError::AssociatedListenerFound(ref cause) => {
write!(f, "{}", cause)
}
DeleteCustomRoutingAcceleratorError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
DeleteCustomRoutingAcceleratorError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteCustomRoutingAcceleratorError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCustomRoutingEndpointGroupError {
EndpointGroupNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl DeleteCustomRoutingEndpointGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteCustomRoutingEndpointGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EndpointGroupNotFoundException" => {
return RusotoError::Service(
DeleteCustomRoutingEndpointGroupError::EndpointGroupNotFound(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
DeleteCustomRoutingEndpointGroupError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
DeleteCustomRoutingEndpointGroupError::InvalidArgument(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteCustomRoutingEndpointGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCustomRoutingEndpointGroupError::EndpointGroupNotFound(ref cause) => {
write!(f, "{}", cause)
}
DeleteCustomRoutingEndpointGroupError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
DeleteCustomRoutingEndpointGroupError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteCustomRoutingEndpointGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCustomRoutingListenerError {
AssociatedEndpointGroupFound(String),
InternalServiceError(String),
InvalidArgument(String),
ListenerNotFound(String),
}
impl DeleteCustomRoutingListenerError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteCustomRoutingListenerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AssociatedEndpointGroupFoundException" => {
return RusotoError::Service(
DeleteCustomRoutingListenerError::AssociatedEndpointGroupFound(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
DeleteCustomRoutingListenerError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(DeleteCustomRoutingListenerError::InvalidArgument(
err.msg,
))
}
"ListenerNotFoundException" => {
return RusotoError::Service(
DeleteCustomRoutingListenerError::ListenerNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteCustomRoutingListenerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCustomRoutingListenerError::AssociatedEndpointGroupFound(ref cause) => {
write!(f, "{}", cause)
}
DeleteCustomRoutingListenerError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
DeleteCustomRoutingListenerError::InvalidArgument(ref cause) => write!(f, "{}", cause),
DeleteCustomRoutingListenerError::ListenerNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteCustomRoutingListenerError {}
#[derive(Debug, PartialEq)]
pub enum DeleteEndpointGroupError {
EndpointGroupNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl DeleteEndpointGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteEndpointGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EndpointGroupNotFoundException" => {
return RusotoError::Service(DeleteEndpointGroupError::EndpointGroupNotFound(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(DeleteEndpointGroupError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(DeleteEndpointGroupError::InvalidArgument(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteEndpointGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteEndpointGroupError::EndpointGroupNotFound(ref cause) => write!(f, "{}", cause),
DeleteEndpointGroupError::InternalServiceError(ref cause) => write!(f, "{}", cause),
DeleteEndpointGroupError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteEndpointGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteListenerError {
AssociatedEndpointGroupFound(String),
InternalServiceError(String),
InvalidArgument(String),
ListenerNotFound(String),
}
impl DeleteListenerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteListenerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AssociatedEndpointGroupFoundException" => {
return RusotoError::Service(DeleteListenerError::AssociatedEndpointGroupFound(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(DeleteListenerError::InternalServiceError(err.msg))
}
"InvalidArgumentException" => {
return RusotoError::Service(DeleteListenerError::InvalidArgument(err.msg))
}
"ListenerNotFoundException" => {
return RusotoError::Service(DeleteListenerError::ListenerNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteListenerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteListenerError::AssociatedEndpointGroupFound(ref cause) => write!(f, "{}", cause),
DeleteListenerError::InternalServiceError(ref cause) => write!(f, "{}", cause),
DeleteListenerError::InvalidArgument(ref cause) => write!(f, "{}", cause),
DeleteListenerError::ListenerNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteListenerError {}
#[derive(Debug, PartialEq)]
pub enum DenyCustomRoutingTrafficError {
InternalServiceError(String),
InvalidArgument(String),
}
impl DenyCustomRoutingTrafficError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DenyCustomRoutingTrafficError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(
DenyCustomRoutingTrafficError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(DenyCustomRoutingTrafficError::InvalidArgument(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DenyCustomRoutingTrafficError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DenyCustomRoutingTrafficError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
DenyCustomRoutingTrafficError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DenyCustomRoutingTrafficError {}
#[derive(Debug, PartialEq)]
pub enum DeprovisionByoipCidrError {
AccessDenied(String),
ByoipCidrNotFound(String),
IncorrectCidrState(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl DeprovisionByoipCidrError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeprovisionByoipCidrError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeprovisionByoipCidrError::AccessDenied(err.msg))
}
"ByoipCidrNotFoundException" => {
return RusotoError::Service(DeprovisionByoipCidrError::ByoipCidrNotFound(
err.msg,
))
}
"IncorrectCidrStateException" => {
return RusotoError::Service(DeprovisionByoipCidrError::IncorrectCidrState(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(DeprovisionByoipCidrError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(DeprovisionByoipCidrError::InvalidArgument(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeprovisionByoipCidrError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeprovisionByoipCidrError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeprovisionByoipCidrError::ByoipCidrNotFound(ref cause) => write!(f, "{}", cause),
DeprovisionByoipCidrError::IncorrectCidrState(ref cause) => write!(f, "{}", cause),
DeprovisionByoipCidrError::InternalServiceError(ref cause) => write!(f, "{}", cause),
DeprovisionByoipCidrError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeprovisionByoipCidrError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAcceleratorError {
AcceleratorNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl DescribeAcceleratorError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAcceleratorError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(DescribeAcceleratorError::AcceleratorNotFound(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(DescribeAcceleratorError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(DescribeAcceleratorError::InvalidArgument(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeAcceleratorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAcceleratorError::AcceleratorNotFound(ref cause) => write!(f, "{}", cause),
DescribeAcceleratorError::InternalServiceError(ref cause) => write!(f, "{}", cause),
DescribeAcceleratorError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeAcceleratorError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAcceleratorAttributesError {
AcceleratorNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl DescribeAcceleratorAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeAcceleratorAttributesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(
DescribeAcceleratorAttributesError::AcceleratorNotFound(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
DescribeAcceleratorAttributesError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
DescribeAcceleratorAttributesError::InvalidArgument(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeAcceleratorAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAcceleratorAttributesError::AcceleratorNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeAcceleratorAttributesError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
DescribeAcceleratorAttributesError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeAcceleratorAttributesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCustomRoutingAcceleratorError {
AcceleratorNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl DescribeCustomRoutingAcceleratorError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeCustomRoutingAcceleratorError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(
DescribeCustomRoutingAcceleratorError::AcceleratorNotFound(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
DescribeCustomRoutingAcceleratorError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
DescribeCustomRoutingAcceleratorError::InvalidArgument(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeCustomRoutingAcceleratorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCustomRoutingAcceleratorError::AcceleratorNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeCustomRoutingAcceleratorError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
DescribeCustomRoutingAcceleratorError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeCustomRoutingAcceleratorError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCustomRoutingAcceleratorAttributesError {
AcceleratorNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl DescribeCustomRoutingAcceleratorAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeCustomRoutingAcceleratorAttributesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(
DescribeCustomRoutingAcceleratorAttributesError::AcceleratorNotFound(
err.msg,
),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
DescribeCustomRoutingAcceleratorAttributesError::InternalServiceError(
err.msg,
),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
DescribeCustomRoutingAcceleratorAttributesError::InvalidArgument(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeCustomRoutingAcceleratorAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCustomRoutingAcceleratorAttributesError::AcceleratorNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeCustomRoutingAcceleratorAttributesError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
DescribeCustomRoutingAcceleratorAttributesError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeCustomRoutingAcceleratorAttributesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCustomRoutingEndpointGroupError {
EndpointGroupNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl DescribeCustomRoutingEndpointGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeCustomRoutingEndpointGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EndpointGroupNotFoundException" => {
return RusotoError::Service(
DescribeCustomRoutingEndpointGroupError::EndpointGroupNotFound(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
DescribeCustomRoutingEndpointGroupError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
DescribeCustomRoutingEndpointGroupError::InvalidArgument(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeCustomRoutingEndpointGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCustomRoutingEndpointGroupError::EndpointGroupNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeCustomRoutingEndpointGroupError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
DescribeCustomRoutingEndpointGroupError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeCustomRoutingEndpointGroupError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCustomRoutingListenerError {
InternalServiceError(String),
InvalidArgument(String),
ListenerNotFound(String),
}
impl DescribeCustomRoutingListenerError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeCustomRoutingListenerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(
DescribeCustomRoutingListenerError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
DescribeCustomRoutingListenerError::InvalidArgument(err.msg),
)
}
"ListenerNotFoundException" => {
return RusotoError::Service(
DescribeCustomRoutingListenerError::ListenerNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeCustomRoutingListenerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCustomRoutingListenerError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
DescribeCustomRoutingListenerError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
DescribeCustomRoutingListenerError::ListenerNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeCustomRoutingListenerError {}
#[derive(Debug, PartialEq)]
pub enum DescribeEndpointGroupError {
EndpointGroupNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl DescribeEndpointGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeEndpointGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EndpointGroupNotFoundException" => {
return RusotoError::Service(DescribeEndpointGroupError::EndpointGroupNotFound(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(DescribeEndpointGroupError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(DescribeEndpointGroupError::InvalidArgument(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeEndpointGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeEndpointGroupError::EndpointGroupNotFound(ref cause) => write!(f, "{}", cause),
DescribeEndpointGroupError::InternalServiceError(ref cause) => write!(f, "{}", cause),
DescribeEndpointGroupError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeEndpointGroupError {}
#[derive(Debug, PartialEq)]
pub enum DescribeListenerError {
InternalServiceError(String),
InvalidArgument(String),
ListenerNotFound(String),
}
impl DescribeListenerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeListenerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(DescribeListenerError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(DescribeListenerError::InvalidArgument(err.msg))
}
"ListenerNotFoundException" => {
return RusotoError::Service(DescribeListenerError::ListenerNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeListenerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeListenerError::InternalServiceError(ref cause) => write!(f, "{}", cause),
DescribeListenerError::InvalidArgument(ref cause) => write!(f, "{}", cause),
DescribeListenerError::ListenerNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeListenerError {}
#[derive(Debug, PartialEq)]
pub enum ListAcceleratorsError {
InternalServiceError(String),
InvalidArgument(String),
InvalidNextToken(String),
}
impl ListAcceleratorsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAcceleratorsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(ListAcceleratorsError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(ListAcceleratorsError::InvalidArgument(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListAcceleratorsError::InvalidNextToken(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAcceleratorsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAcceleratorsError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListAcceleratorsError::InvalidArgument(ref cause) => write!(f, "{}", cause),
ListAcceleratorsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListAcceleratorsError {}
#[derive(Debug, PartialEq)]
pub enum ListByoipCidrsError {
AccessDenied(String),
InternalServiceError(String),
InvalidArgument(String),
InvalidNextToken(String),
}
impl ListByoipCidrsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListByoipCidrsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListByoipCidrsError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(ListByoipCidrsError::InternalServiceError(err.msg))
}
"InvalidArgumentException" => {
return RusotoError::Service(ListByoipCidrsError::InvalidArgument(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListByoipCidrsError::InvalidNextToken(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListByoipCidrsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListByoipCidrsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListByoipCidrsError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListByoipCidrsError::InvalidArgument(ref cause) => write!(f, "{}", cause),
ListByoipCidrsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListByoipCidrsError {}
#[derive(Debug, PartialEq)]
pub enum ListCustomRoutingAcceleratorsError {
InternalServiceError(String),
InvalidArgument(String),
InvalidNextToken(String),
}
impl ListCustomRoutingAcceleratorsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListCustomRoutingAcceleratorsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(
ListCustomRoutingAcceleratorsError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
ListCustomRoutingAcceleratorsError::InvalidArgument(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
ListCustomRoutingAcceleratorsError::InvalidNextToken(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListCustomRoutingAcceleratorsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListCustomRoutingAcceleratorsError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingAcceleratorsError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingAcceleratorsError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListCustomRoutingAcceleratorsError {}
#[derive(Debug, PartialEq)]
pub enum ListCustomRoutingEndpointGroupsError {
InternalServiceError(String),
InvalidArgument(String),
InvalidNextToken(String),
ListenerNotFound(String),
}
impl ListCustomRoutingEndpointGroupsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListCustomRoutingEndpointGroupsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(
ListCustomRoutingEndpointGroupsError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
ListCustomRoutingEndpointGroupsError::InvalidArgument(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
ListCustomRoutingEndpointGroupsError::InvalidNextToken(err.msg),
)
}
"ListenerNotFoundException" => {
return RusotoError::Service(
ListCustomRoutingEndpointGroupsError::ListenerNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListCustomRoutingEndpointGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListCustomRoutingEndpointGroupsError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingEndpointGroupsError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingEndpointGroupsError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingEndpointGroupsError::ListenerNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListCustomRoutingEndpointGroupsError {}
#[derive(Debug, PartialEq)]
pub enum ListCustomRoutingListenersError {
AcceleratorNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
InvalidNextToken(String),
}
impl ListCustomRoutingListenersError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListCustomRoutingListenersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(
ListCustomRoutingListenersError::AcceleratorNotFound(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
ListCustomRoutingListenersError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(ListCustomRoutingListenersError::InvalidArgument(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListCustomRoutingListenersError::InvalidNextToken(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListCustomRoutingListenersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListCustomRoutingListenersError::AcceleratorNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingListenersError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingListenersError::InvalidArgument(ref cause) => write!(f, "{}", cause),
ListCustomRoutingListenersError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListCustomRoutingListenersError {}
#[derive(Debug, PartialEq)]
pub enum ListCustomRoutingPortMappingsError {
AcceleratorNotFound(String),
EndpointGroupNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
InvalidNextToken(String),
}
impl ListCustomRoutingPortMappingsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListCustomRoutingPortMappingsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(
ListCustomRoutingPortMappingsError::AcceleratorNotFound(err.msg),
)
}
"EndpointGroupNotFoundException" => {
return RusotoError::Service(
ListCustomRoutingPortMappingsError::EndpointGroupNotFound(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
ListCustomRoutingPortMappingsError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
ListCustomRoutingPortMappingsError::InvalidArgument(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
ListCustomRoutingPortMappingsError::InvalidNextToken(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListCustomRoutingPortMappingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListCustomRoutingPortMappingsError::AcceleratorNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingPortMappingsError::EndpointGroupNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingPortMappingsError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingPortMappingsError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingPortMappingsError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListCustomRoutingPortMappingsError {}
#[derive(Debug, PartialEq)]
pub enum ListCustomRoutingPortMappingsByDestinationError {
EndpointNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
InvalidNextToken(String),
}
impl ListCustomRoutingPortMappingsByDestinationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListCustomRoutingPortMappingsByDestinationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EndpointNotFoundException" => {
return RusotoError::Service(
ListCustomRoutingPortMappingsByDestinationError::EndpointNotFound(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
ListCustomRoutingPortMappingsByDestinationError::InternalServiceError(
err.msg,
),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
ListCustomRoutingPortMappingsByDestinationError::InvalidArgument(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
ListCustomRoutingPortMappingsByDestinationError::InvalidNextToken(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListCustomRoutingPortMappingsByDestinationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListCustomRoutingPortMappingsByDestinationError::EndpointNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingPortMappingsByDestinationError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingPortMappingsByDestinationError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
ListCustomRoutingPortMappingsByDestinationError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListCustomRoutingPortMappingsByDestinationError {}
#[derive(Debug, PartialEq)]
pub enum ListEndpointGroupsError {
InternalServiceError(String),
InvalidArgument(String),
InvalidNextToken(String),
ListenerNotFound(String),
}
impl ListEndpointGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListEndpointGroupsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(ListEndpointGroupsError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(ListEndpointGroupsError::InvalidArgument(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListEndpointGroupsError::InvalidNextToken(err.msg))
}
"ListenerNotFoundException" => {
return RusotoError::Service(ListEndpointGroupsError::ListenerNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListEndpointGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListEndpointGroupsError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListEndpointGroupsError::InvalidArgument(ref cause) => write!(f, "{}", cause),
ListEndpointGroupsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListEndpointGroupsError::ListenerNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListEndpointGroupsError {}
#[derive(Debug, PartialEq)]
pub enum ListListenersError {
AcceleratorNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
InvalidNextToken(String),
}
impl ListListenersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListListenersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(ListListenersError::AcceleratorNotFound(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(ListListenersError::InternalServiceError(err.msg))
}
"InvalidArgumentException" => {
return RusotoError::Service(ListListenersError::InvalidArgument(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListListenersError::InvalidNextToken(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListListenersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListListenersError::AcceleratorNotFound(ref cause) => write!(f, "{}", cause),
ListListenersError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListListenersError::InvalidArgument(ref cause) => write!(f, "{}", cause),
ListListenersError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListListenersError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
AcceleratorNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::AcceleratorNotFound(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(ListTagsForResourceError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidArgument(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::AcceleratorNotFound(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ProvisionByoipCidrError {
AccessDenied(String),
IncorrectCidrState(String),
InternalServiceError(String),
InvalidArgument(String),
LimitExceeded(String),
}
impl ProvisionByoipCidrError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ProvisionByoipCidrError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ProvisionByoipCidrError::AccessDenied(err.msg))
}
"IncorrectCidrStateException" => {
return RusotoError::Service(ProvisionByoipCidrError::IncorrectCidrState(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(ProvisionByoipCidrError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(ProvisionByoipCidrError::InvalidArgument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ProvisionByoipCidrError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ProvisionByoipCidrError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ProvisionByoipCidrError::AccessDenied(ref cause) => write!(f, "{}", cause),
ProvisionByoipCidrError::IncorrectCidrState(ref cause) => write!(f, "{}", cause),
ProvisionByoipCidrError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ProvisionByoipCidrError::InvalidArgument(ref cause) => write!(f, "{}", cause),
ProvisionByoipCidrError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ProvisionByoipCidrError {}
#[derive(Debug, PartialEq)]
pub enum RemoveCustomRoutingEndpointsError {
AccessDenied(String),
Conflict(String),
EndpointGroupNotFound(String),
EndpointNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl RemoveCustomRoutingEndpointsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RemoveCustomRoutingEndpointsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(RemoveCustomRoutingEndpointsError::AccessDenied(
err.msg,
))
}
"ConflictException" => {
return RusotoError::Service(RemoveCustomRoutingEndpointsError::Conflict(
err.msg,
))
}
"EndpointGroupNotFoundException" => {
return RusotoError::Service(
RemoveCustomRoutingEndpointsError::EndpointGroupNotFound(err.msg),
)
}
"EndpointNotFoundException" => {
return RusotoError::Service(
RemoveCustomRoutingEndpointsError::EndpointNotFound(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
RemoveCustomRoutingEndpointsError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
RemoveCustomRoutingEndpointsError::InvalidArgument(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RemoveCustomRoutingEndpointsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemoveCustomRoutingEndpointsError::AccessDenied(ref cause) => write!(f, "{}", cause),
RemoveCustomRoutingEndpointsError::Conflict(ref cause) => write!(f, "{}", cause),
RemoveCustomRoutingEndpointsError::EndpointGroupNotFound(ref cause) => {
write!(f, "{}", cause)
}
RemoveCustomRoutingEndpointsError::EndpointNotFound(ref cause) => {
write!(f, "{}", cause)
}
RemoveCustomRoutingEndpointsError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
RemoveCustomRoutingEndpointsError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemoveCustomRoutingEndpointsError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
AcceleratorNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(TagResourceError::AcceleratorNotFound(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(TagResourceError::InternalServiceError(err.msg))
}
"InvalidArgumentException" => {
return RusotoError::Service(TagResourceError::InvalidArgument(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::AcceleratorNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::InternalServiceError(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
AcceleratorNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(UntagResourceError::AcceleratorNotFound(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(UntagResourceError::InternalServiceError(err.msg))
}
"InvalidArgumentException" => {
return RusotoError::Service(UntagResourceError::InvalidArgument(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::AcceleratorNotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::InternalServiceError(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateAcceleratorError {
AcceleratorNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl UpdateAcceleratorError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateAcceleratorError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(UpdateAcceleratorError::AcceleratorNotFound(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(UpdateAcceleratorError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(UpdateAcceleratorError::InvalidArgument(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateAcceleratorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateAcceleratorError::AcceleratorNotFound(ref cause) => write!(f, "{}", cause),
UpdateAcceleratorError::InternalServiceError(ref cause) => write!(f, "{}", cause),
UpdateAcceleratorError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateAcceleratorError {}
#[derive(Debug, PartialEq)]
pub enum UpdateAcceleratorAttributesError {
AcceleratorNotFound(String),
AccessDenied(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl UpdateAcceleratorAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateAcceleratorAttributesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(
UpdateAcceleratorAttributesError::AcceleratorNotFound(err.msg),
)
}
"AccessDeniedException" => {
return RusotoError::Service(UpdateAcceleratorAttributesError::AccessDenied(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(
UpdateAcceleratorAttributesError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(UpdateAcceleratorAttributesError::InvalidArgument(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateAcceleratorAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateAcceleratorAttributesError::AcceleratorNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdateAcceleratorAttributesError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateAcceleratorAttributesError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
UpdateAcceleratorAttributesError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateAcceleratorAttributesError {}
#[derive(Debug, PartialEq)]
pub enum UpdateCustomRoutingAcceleratorError {
AcceleratorNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl UpdateCustomRoutingAcceleratorError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateCustomRoutingAcceleratorError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(
UpdateCustomRoutingAcceleratorError::AcceleratorNotFound(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
UpdateCustomRoutingAcceleratorError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
UpdateCustomRoutingAcceleratorError::InvalidArgument(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateCustomRoutingAcceleratorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateCustomRoutingAcceleratorError::AcceleratorNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdateCustomRoutingAcceleratorError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
UpdateCustomRoutingAcceleratorError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateCustomRoutingAcceleratorError {}
#[derive(Debug, PartialEq)]
pub enum UpdateCustomRoutingAcceleratorAttributesError {
AcceleratorNotFound(String),
AccessDenied(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl UpdateCustomRoutingAcceleratorAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateCustomRoutingAcceleratorAttributesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AcceleratorNotFoundException" => {
return RusotoError::Service(
UpdateCustomRoutingAcceleratorAttributesError::AcceleratorNotFound(err.msg),
)
}
"AccessDeniedException" => {
return RusotoError::Service(
UpdateCustomRoutingAcceleratorAttributesError::AccessDenied(err.msg),
)
}
"InternalServiceErrorException" => {
return RusotoError::Service(
UpdateCustomRoutingAcceleratorAttributesError::InternalServiceError(
err.msg,
),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
UpdateCustomRoutingAcceleratorAttributesError::InvalidArgument(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateCustomRoutingAcceleratorAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateCustomRoutingAcceleratorAttributesError::AcceleratorNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdateCustomRoutingAcceleratorAttributesError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
UpdateCustomRoutingAcceleratorAttributesError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
UpdateCustomRoutingAcceleratorAttributesError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateCustomRoutingAcceleratorAttributesError {}
#[derive(Debug, PartialEq)]
pub enum UpdateCustomRoutingListenerError {
InternalServiceError(String),
InvalidArgument(String),
InvalidPortRange(String),
LimitExceeded(String),
ListenerNotFound(String),
}
impl UpdateCustomRoutingListenerError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateCustomRoutingListenerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(
UpdateCustomRoutingListenerError::InternalServiceError(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(UpdateCustomRoutingListenerError::InvalidArgument(
err.msg,
))
}
"InvalidPortRangeException" => {
return RusotoError::Service(
UpdateCustomRoutingListenerError::InvalidPortRange(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(UpdateCustomRoutingListenerError::LimitExceeded(
err.msg,
))
}
"ListenerNotFoundException" => {
return RusotoError::Service(
UpdateCustomRoutingListenerError::ListenerNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateCustomRoutingListenerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateCustomRoutingListenerError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
UpdateCustomRoutingListenerError::InvalidArgument(ref cause) => write!(f, "{}", cause),
UpdateCustomRoutingListenerError::InvalidPortRange(ref cause) => write!(f, "{}", cause),
UpdateCustomRoutingListenerError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateCustomRoutingListenerError::ListenerNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateCustomRoutingListenerError {}
#[derive(Debug, PartialEq)]
pub enum UpdateEndpointGroupError {
AccessDenied(String),
EndpointGroupNotFound(String),
InternalServiceError(String),
InvalidArgument(String),
LimitExceeded(String),
}
impl UpdateEndpointGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateEndpointGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateEndpointGroupError::AccessDenied(err.msg))
}
"EndpointGroupNotFoundException" => {
return RusotoError::Service(UpdateEndpointGroupError::EndpointGroupNotFound(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(UpdateEndpointGroupError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(UpdateEndpointGroupError::InvalidArgument(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateEndpointGroupError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateEndpointGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateEndpointGroupError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateEndpointGroupError::EndpointGroupNotFound(ref cause) => write!(f, "{}", cause),
UpdateEndpointGroupError::InternalServiceError(ref cause) => write!(f, "{}", cause),
UpdateEndpointGroupError::InvalidArgument(ref cause) => write!(f, "{}", cause),
UpdateEndpointGroupError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateEndpointGroupError {}
#[derive(Debug, PartialEq)]
pub enum UpdateListenerError {
InternalServiceError(String),
InvalidArgument(String),
InvalidPortRange(String),
LimitExceeded(String),
ListenerNotFound(String),
}
impl UpdateListenerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateListenerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(UpdateListenerError::InternalServiceError(err.msg))
}
"InvalidArgumentException" => {
return RusotoError::Service(UpdateListenerError::InvalidArgument(err.msg))
}
"InvalidPortRangeException" => {
return RusotoError::Service(UpdateListenerError::InvalidPortRange(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateListenerError::LimitExceeded(err.msg))
}
"ListenerNotFoundException" => {
return RusotoError::Service(UpdateListenerError::ListenerNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateListenerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateListenerError::InternalServiceError(ref cause) => write!(f, "{}", cause),
UpdateListenerError::InvalidArgument(ref cause) => write!(f, "{}", cause),
UpdateListenerError::InvalidPortRange(ref cause) => write!(f, "{}", cause),
UpdateListenerError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateListenerError::ListenerNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateListenerError {}
#[derive(Debug, PartialEq)]
pub enum WithdrawByoipCidrError {
AccessDenied(String),
ByoipCidrNotFound(String),
IncorrectCidrState(String),
InternalServiceError(String),
InvalidArgument(String),
}
impl WithdrawByoipCidrError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<WithdrawByoipCidrError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(WithdrawByoipCidrError::AccessDenied(err.msg))
}
"ByoipCidrNotFoundException" => {
return RusotoError::Service(WithdrawByoipCidrError::ByoipCidrNotFound(err.msg))
}
"IncorrectCidrStateException" => {
return RusotoError::Service(WithdrawByoipCidrError::IncorrectCidrState(
err.msg,
))
}
"InternalServiceErrorException" => {
return RusotoError::Service(WithdrawByoipCidrError::InternalServiceError(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(WithdrawByoipCidrError::InvalidArgument(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for WithdrawByoipCidrError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
WithdrawByoipCidrError::AccessDenied(ref cause) => write!(f, "{}", cause),
WithdrawByoipCidrError::ByoipCidrNotFound(ref cause) => write!(f, "{}", cause),
WithdrawByoipCidrError::IncorrectCidrState(ref cause) => write!(f, "{}", cause),
WithdrawByoipCidrError::InternalServiceError(ref cause) => write!(f, "{}", cause),
WithdrawByoipCidrError::InvalidArgument(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for WithdrawByoipCidrError {}
#[async_trait]
pub trait GlobalAccelerator {
async fn add_custom_routing_endpoints(
&self,
input: AddCustomRoutingEndpointsRequest,
) -> Result<AddCustomRoutingEndpointsResponse, RusotoError<AddCustomRoutingEndpointsError>>;
async fn advertise_byoip_cidr(
&self,
input: AdvertiseByoipCidrRequest,
) -> Result<AdvertiseByoipCidrResponse, RusotoError<AdvertiseByoipCidrError>>;
async fn allow_custom_routing_traffic(
&self,
input: AllowCustomRoutingTrafficRequest,
) -> Result<(), RusotoError<AllowCustomRoutingTrafficError>>;
async fn create_accelerator(
&self,
input: CreateAcceleratorRequest,
) -> Result<CreateAcceleratorResponse, RusotoError<CreateAcceleratorError>>;
async fn create_custom_routing_accelerator(
&self,
input: CreateCustomRoutingAcceleratorRequest,
) -> Result<
CreateCustomRoutingAcceleratorResponse,
RusotoError<CreateCustomRoutingAcceleratorError>,
>;
async fn create_custom_routing_endpoint_group(
&self,
input: CreateCustomRoutingEndpointGroupRequest,
) -> Result<
CreateCustomRoutingEndpointGroupResponse,
RusotoError<CreateCustomRoutingEndpointGroupError>,
>;
async fn create_custom_routing_listener(
&self,
input: CreateCustomRoutingListenerRequest,
) -> Result<CreateCustomRoutingListenerResponse, RusotoError<CreateCustomRoutingListenerError>>;
async fn create_endpoint_group(
&self,
input: CreateEndpointGroupRequest,
) -> Result<CreateEndpointGroupResponse, RusotoError<CreateEndpointGroupError>>;
async fn create_listener(
&self,
input: CreateListenerRequest,
) -> Result<CreateListenerResponse, RusotoError<CreateListenerError>>;
async fn delete_accelerator(
&self,
input: DeleteAcceleratorRequest,
) -> Result<(), RusotoError<DeleteAcceleratorError>>;
async fn delete_custom_routing_accelerator(
&self,
input: DeleteCustomRoutingAcceleratorRequest,
) -> Result<(), RusotoError<DeleteCustomRoutingAcceleratorError>>;
async fn delete_custom_routing_endpoint_group(
&self,
input: DeleteCustomRoutingEndpointGroupRequest,
) -> Result<(), RusotoError<DeleteCustomRoutingEndpointGroupError>>;
async fn delete_custom_routing_listener(
&self,
input: DeleteCustomRoutingListenerRequest,
) -> Result<(), RusotoError<DeleteCustomRoutingListenerError>>;
async fn delete_endpoint_group(
&self,
input: DeleteEndpointGroupRequest,
) -> Result<(), RusotoError<DeleteEndpointGroupError>>;
async fn delete_listener(
&self,
input: DeleteListenerRequest,
) -> Result<(), RusotoError<DeleteListenerError>>;
async fn deny_custom_routing_traffic(
&self,
input: DenyCustomRoutingTrafficRequest,
) -> Result<(), RusotoError<DenyCustomRoutingTrafficError>>;
async fn deprovision_byoip_cidr(
&self,
input: DeprovisionByoipCidrRequest,
) -> Result<DeprovisionByoipCidrResponse, RusotoError<DeprovisionByoipCidrError>>;
async fn describe_accelerator(
&self,
input: DescribeAcceleratorRequest,
) -> Result<DescribeAcceleratorResponse, RusotoError<DescribeAcceleratorError>>;
async fn describe_accelerator_attributes(
&self,
input: DescribeAcceleratorAttributesRequest,
) -> Result<
DescribeAcceleratorAttributesResponse,
RusotoError<DescribeAcceleratorAttributesError>,
>;
async fn describe_custom_routing_accelerator(
&self,
input: DescribeCustomRoutingAcceleratorRequest,
) -> Result<
DescribeCustomRoutingAcceleratorResponse,
RusotoError<DescribeCustomRoutingAcceleratorError>,
>;
async fn describe_custom_routing_accelerator_attributes(
&self,
input: DescribeCustomRoutingAcceleratorAttributesRequest,
) -> Result<
DescribeCustomRoutingAcceleratorAttributesResponse,
RusotoError<DescribeCustomRoutingAcceleratorAttributesError>,
>;
async fn describe_custom_routing_endpoint_group(
&self,
input: DescribeCustomRoutingEndpointGroupRequest,
) -> Result<
DescribeCustomRoutingEndpointGroupResponse,
RusotoError<DescribeCustomRoutingEndpointGroupError>,
>;
async fn describe_custom_routing_listener(
&self,
input: DescribeCustomRoutingListenerRequest,
) -> Result<
DescribeCustomRoutingListenerResponse,
RusotoError<DescribeCustomRoutingListenerError>,
>;
async fn describe_endpoint_group(
&self,
input: DescribeEndpointGroupRequest,
) -> Result<DescribeEndpointGroupResponse, RusotoError<DescribeEndpointGroupError>>;
async fn describe_listener(
&self,
input: DescribeListenerRequest,
) -> Result<DescribeListenerResponse, RusotoError<DescribeListenerError>>;
async fn list_accelerators(
&self,
input: ListAcceleratorsRequest,
) -> Result<ListAcceleratorsResponse, RusotoError<ListAcceleratorsError>>;
async fn list_byoip_cidrs(
&self,
input: ListByoipCidrsRequest,
) -> Result<ListByoipCidrsResponse, RusotoError<ListByoipCidrsError>>;
async fn list_custom_routing_accelerators(
&self,
input: ListCustomRoutingAcceleratorsRequest,
) -> Result<
ListCustomRoutingAcceleratorsResponse,
RusotoError<ListCustomRoutingAcceleratorsError>,
>;
async fn list_custom_routing_endpoint_groups(
&self,
input: ListCustomRoutingEndpointGroupsRequest,
) -> Result<
ListCustomRoutingEndpointGroupsResponse,
RusotoError<ListCustomRoutingEndpointGroupsError>,
>;
async fn list_custom_routing_listeners(
&self,
input: ListCustomRoutingListenersRequest,
) -> Result<ListCustomRoutingListenersResponse, RusotoError<ListCustomRoutingListenersError>>;
async fn list_custom_routing_port_mappings(
&self,
input: ListCustomRoutingPortMappingsRequest,
) -> Result<
ListCustomRoutingPortMappingsResponse,
RusotoError<ListCustomRoutingPortMappingsError>,
>;
async fn list_custom_routing_port_mappings_by_destination(
&self,
input: ListCustomRoutingPortMappingsByDestinationRequest,
) -> Result<
ListCustomRoutingPortMappingsByDestinationResponse,
RusotoError<ListCustomRoutingPortMappingsByDestinationError>,
>;
async fn list_endpoint_groups(
&self,
input: ListEndpointGroupsRequest,
) -> Result<ListEndpointGroupsResponse, RusotoError<ListEndpointGroupsError>>;
async fn list_listeners(
&self,
input: ListListenersRequest,
) -> Result<ListListenersResponse, RusotoError<ListListenersError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn provision_byoip_cidr(
&self,
input: ProvisionByoipCidrRequest,
) -> Result<ProvisionByoipCidrResponse, RusotoError<ProvisionByoipCidrError>>;
async fn remove_custom_routing_endpoints(
&self,
input: RemoveCustomRoutingEndpointsRequest,
) -> Result<(), RusotoError<RemoveCustomRoutingEndpointsError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_accelerator(
&self,
input: UpdateAcceleratorRequest,
) -> Result<UpdateAcceleratorResponse, RusotoError<UpdateAcceleratorError>>;
async fn update_accelerator_attributes(
&self,
input: UpdateAcceleratorAttributesRequest,
) -> Result<UpdateAcceleratorAttributesResponse, RusotoError<UpdateAcceleratorAttributesError>>;
async fn update_custom_routing_accelerator(
&self,
input: UpdateCustomRoutingAcceleratorRequest,
) -> Result<
UpdateCustomRoutingAcceleratorResponse,
RusotoError<UpdateCustomRoutingAcceleratorError>,
>;
async fn update_custom_routing_accelerator_attributes(
&self,
input: UpdateCustomRoutingAcceleratorAttributesRequest,
) -> Result<
UpdateCustomRoutingAcceleratorAttributesResponse,
RusotoError<UpdateCustomRoutingAcceleratorAttributesError>,
>;
async fn update_custom_routing_listener(
&self,
input: UpdateCustomRoutingListenerRequest,
) -> Result<UpdateCustomRoutingListenerResponse, RusotoError<UpdateCustomRoutingListenerError>>;
async fn update_endpoint_group(
&self,
input: UpdateEndpointGroupRequest,
) -> Result<UpdateEndpointGroupResponse, RusotoError<UpdateEndpointGroupError>>;
async fn update_listener(
&self,
input: UpdateListenerRequest,
) -> Result<UpdateListenerResponse, RusotoError<UpdateListenerError>>;
async fn withdraw_byoip_cidr(
&self,
input: WithdrawByoipCidrRequest,
) -> Result<WithdrawByoipCidrResponse, RusotoError<WithdrawByoipCidrError>>;
}
#[derive(Clone)]
pub struct GlobalAcceleratorClient {
client: Client,
region: region::Region,
}
impl GlobalAcceleratorClient {
pub fn new(region: region::Region) -> GlobalAcceleratorClient {
GlobalAcceleratorClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> GlobalAcceleratorClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
GlobalAcceleratorClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> GlobalAcceleratorClient {
GlobalAcceleratorClient { client, region }
}
}
#[async_trait]
impl GlobalAccelerator for GlobalAcceleratorClient {
async fn add_custom_routing_endpoints(
&self,
input: AddCustomRoutingEndpointsRequest,
) -> Result<AddCustomRoutingEndpointsResponse, RusotoError<AddCustomRoutingEndpointsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.AddCustomRoutingEndpoints",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AddCustomRoutingEndpointsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AddCustomRoutingEndpointsResponse, _>()
}
async fn advertise_byoip_cidr(
&self,
input: AdvertiseByoipCidrRequest,
) -> Result<AdvertiseByoipCidrResponse, RusotoError<AdvertiseByoipCidrError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.AdvertiseByoipCidr",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdvertiseByoipCidrError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AdvertiseByoipCidrResponse, _>()
}
async fn allow_custom_routing_traffic(
&self,
input: AllowCustomRoutingTrafficRequest,
) -> Result<(), RusotoError<AllowCustomRoutingTrafficError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.AllowCustomRoutingTraffic",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AllowCustomRoutingTrafficError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn create_accelerator(
&self,
input: CreateAcceleratorRequest,
) -> Result<CreateAcceleratorResponse, RusotoError<CreateAcceleratorError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.CreateAccelerator",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateAcceleratorError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateAcceleratorResponse, _>()
}
async fn create_custom_routing_accelerator(
&self,
input: CreateCustomRoutingAcceleratorRequest,
) -> Result<
CreateCustomRoutingAcceleratorResponse,
RusotoError<CreateCustomRoutingAcceleratorError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.CreateCustomRoutingAccelerator",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateCustomRoutingAcceleratorError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateCustomRoutingAcceleratorResponse, _>()
}
async fn create_custom_routing_endpoint_group(
&self,
input: CreateCustomRoutingEndpointGroupRequest,
) -> Result<
CreateCustomRoutingEndpointGroupResponse,
RusotoError<CreateCustomRoutingEndpointGroupError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.CreateCustomRoutingEndpointGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
CreateCustomRoutingEndpointGroupError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateCustomRoutingEndpointGroupResponse, _>()
}
async fn create_custom_routing_listener(
&self,
input: CreateCustomRoutingListenerRequest,
) -> Result<CreateCustomRoutingListenerResponse, RusotoError<CreateCustomRoutingListenerError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.CreateCustomRoutingListener",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateCustomRoutingListenerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateCustomRoutingListenerResponse, _>()
}
async fn create_endpoint_group(
&self,
input: CreateEndpointGroupRequest,
) -> Result<CreateEndpointGroupResponse, RusotoError<CreateEndpointGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.CreateEndpointGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateEndpointGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateEndpointGroupResponse, _>()
}
async fn create_listener(
&self,
input: CreateListenerRequest,
) -> Result<CreateListenerResponse, RusotoError<CreateListenerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "GlobalAccelerator_V20180706.CreateListener");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateListenerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateListenerResponse, _>()
}
async fn delete_accelerator(
&self,
input: DeleteAcceleratorRequest,
) -> Result<(), RusotoError<DeleteAcceleratorError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DeleteAccelerator",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteAcceleratorError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_custom_routing_accelerator(
&self,
input: DeleteCustomRoutingAcceleratorRequest,
) -> Result<(), RusotoError<DeleteCustomRoutingAcceleratorError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DeleteCustomRoutingAccelerator",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteCustomRoutingAcceleratorError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_custom_routing_endpoint_group(
&self,
input: DeleteCustomRoutingEndpointGroupRequest,
) -> Result<(), RusotoError<DeleteCustomRoutingEndpointGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DeleteCustomRoutingEndpointGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DeleteCustomRoutingEndpointGroupError::from_response,
)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_custom_routing_listener(
&self,
input: DeleteCustomRoutingListenerRequest,
) -> Result<(), RusotoError<DeleteCustomRoutingListenerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DeleteCustomRoutingListener",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteCustomRoutingListenerError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_endpoint_group(
&self,
input: DeleteEndpointGroupRequest,
) -> Result<(), RusotoError<DeleteEndpointGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DeleteEndpointGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteEndpointGroupError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_listener(
&self,
input: DeleteListenerRequest,
) -> Result<(), RusotoError<DeleteListenerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "GlobalAccelerator_V20180706.DeleteListener");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteListenerError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn deny_custom_routing_traffic(
&self,
input: DenyCustomRoutingTrafficRequest,
) -> Result<(), RusotoError<DenyCustomRoutingTrafficError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DenyCustomRoutingTraffic",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DenyCustomRoutingTrafficError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn deprovision_byoip_cidr(
&self,
input: DeprovisionByoipCidrRequest,
) -> Result<DeprovisionByoipCidrResponse, RusotoError<DeprovisionByoipCidrError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DeprovisionByoipCidr",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeprovisionByoipCidrError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeprovisionByoipCidrResponse, _>()
}
async fn describe_accelerator(
&self,
input: DescribeAcceleratorRequest,
) -> Result<DescribeAcceleratorResponse, RusotoError<DescribeAcceleratorError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DescribeAccelerator",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeAcceleratorError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeAcceleratorResponse, _>()
}
async fn describe_accelerator_attributes(
&self,
input: DescribeAcceleratorAttributesRequest,
) -> Result<
DescribeAcceleratorAttributesResponse,
RusotoError<DescribeAcceleratorAttributesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DescribeAcceleratorAttributes",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeAcceleratorAttributesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeAcceleratorAttributesResponse, _>()
}
async fn describe_custom_routing_accelerator(
&self,
input: DescribeCustomRoutingAcceleratorRequest,
) -> Result<
DescribeCustomRoutingAcceleratorResponse,
RusotoError<DescribeCustomRoutingAcceleratorError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DescribeCustomRoutingAccelerator",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeCustomRoutingAcceleratorError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeCustomRoutingAcceleratorResponse, _>()
}
async fn describe_custom_routing_accelerator_attributes(
&self,
input: DescribeCustomRoutingAcceleratorAttributesRequest,
) -> Result<
DescribeCustomRoutingAcceleratorAttributesResponse,
RusotoError<DescribeCustomRoutingAcceleratorAttributesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DescribeCustomRoutingAcceleratorAttributes",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeCustomRoutingAcceleratorAttributesError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeCustomRoutingAcceleratorAttributesResponse, _>()
}
async fn describe_custom_routing_endpoint_group(
&self,
input: DescribeCustomRoutingEndpointGroupRequest,
) -> Result<
DescribeCustomRoutingEndpointGroupResponse,
RusotoError<DescribeCustomRoutingEndpointGroupError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DescribeCustomRoutingEndpointGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeCustomRoutingEndpointGroupError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeCustomRoutingEndpointGroupResponse, _>()
}
async fn describe_custom_routing_listener(
&self,
input: DescribeCustomRoutingListenerRequest,
) -> Result<
DescribeCustomRoutingListenerResponse,
RusotoError<DescribeCustomRoutingListenerError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DescribeCustomRoutingListener",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeCustomRoutingListenerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeCustomRoutingListenerResponse, _>()
}
async fn describe_endpoint_group(
&self,
input: DescribeEndpointGroupRequest,
) -> Result<DescribeEndpointGroupResponse, RusotoError<DescribeEndpointGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DescribeEndpointGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeEndpointGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeEndpointGroupResponse, _>()
}
async fn describe_listener(
&self,
input: DescribeListenerRequest,
) -> Result<DescribeListenerResponse, RusotoError<DescribeListenerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.DescribeListener",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeListenerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeListenerResponse, _>()
}
async fn list_accelerators(
&self,
input: ListAcceleratorsRequest,
) -> Result<ListAcceleratorsResponse, RusotoError<ListAcceleratorsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.ListAccelerators",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListAcceleratorsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListAcceleratorsResponse, _>()
}
async fn list_byoip_cidrs(
&self,
input: ListByoipCidrsRequest,
) -> Result<ListByoipCidrsResponse, RusotoError<ListByoipCidrsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "GlobalAccelerator_V20180706.ListByoipCidrs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListByoipCidrsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListByoipCidrsResponse, _>()
}
async fn list_custom_routing_accelerators(
&self,
input: ListCustomRoutingAcceleratorsRequest,
) -> Result<
ListCustomRoutingAcceleratorsResponse,
RusotoError<ListCustomRoutingAcceleratorsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.ListCustomRoutingAccelerators",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListCustomRoutingAcceleratorsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListCustomRoutingAcceleratorsResponse, _>()
}
async fn list_custom_routing_endpoint_groups(
&self,
input: ListCustomRoutingEndpointGroupsRequest,
) -> Result<
ListCustomRoutingEndpointGroupsResponse,
RusotoError<ListCustomRoutingEndpointGroupsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.ListCustomRoutingEndpointGroups",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListCustomRoutingEndpointGroupsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListCustomRoutingEndpointGroupsResponse, _>()
}
async fn list_custom_routing_listeners(
&self,
input: ListCustomRoutingListenersRequest,
) -> Result<ListCustomRoutingListenersResponse, RusotoError<ListCustomRoutingListenersError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.ListCustomRoutingListeners",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListCustomRoutingListenersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListCustomRoutingListenersResponse, _>()
}
async fn list_custom_routing_port_mappings(
&self,
input: ListCustomRoutingPortMappingsRequest,
) -> Result<
ListCustomRoutingPortMappingsResponse,
RusotoError<ListCustomRoutingPortMappingsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.ListCustomRoutingPortMappings",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListCustomRoutingPortMappingsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListCustomRoutingPortMappingsResponse, _>()
}
async fn list_custom_routing_port_mappings_by_destination(
&self,
input: ListCustomRoutingPortMappingsByDestinationRequest,
) -> Result<
ListCustomRoutingPortMappingsByDestinationResponse,
RusotoError<ListCustomRoutingPortMappingsByDestinationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.ListCustomRoutingPortMappingsByDestination",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListCustomRoutingPortMappingsByDestinationError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListCustomRoutingPortMappingsByDestinationResponse, _>()
}
async fn list_endpoint_groups(
&self,
input: ListEndpointGroupsRequest,
) -> Result<ListEndpointGroupsResponse, RusotoError<ListEndpointGroupsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.ListEndpointGroups",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListEndpointGroupsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListEndpointGroupsResponse, _>()
}
async fn list_listeners(
&self,
input: ListListenersRequest,
) -> Result<ListListenersResponse, RusotoError<ListListenersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "GlobalAccelerator_V20180706.ListListeners");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListListenersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListListenersResponse, _>()
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.ListTagsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceResponse, _>()
}
async fn provision_byoip_cidr(
&self,
input: ProvisionByoipCidrRequest,
) -> Result<ProvisionByoipCidrResponse, RusotoError<ProvisionByoipCidrError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.ProvisionByoipCidr",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ProvisionByoipCidrError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ProvisionByoipCidrResponse, _>()
}
async fn remove_custom_routing_endpoints(
&self,
input: RemoveCustomRoutingEndpointsRequest,
) -> Result<(), RusotoError<RemoveCustomRoutingEndpointsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.RemoveCustomRoutingEndpoints",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RemoveCustomRoutingEndpointsError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "GlobalAccelerator_V20180706.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceResponse, _>()
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "GlobalAccelerator_V20180706.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceResponse, _>()
}
async fn update_accelerator(
&self,
input: UpdateAcceleratorRequest,
) -> Result<UpdateAcceleratorResponse, RusotoError<UpdateAcceleratorError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.UpdateAccelerator",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateAcceleratorError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateAcceleratorResponse, _>()
}
async fn update_accelerator_attributes(
&self,
input: UpdateAcceleratorAttributesRequest,
) -> Result<UpdateAcceleratorAttributesResponse, RusotoError<UpdateAcceleratorAttributesError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.UpdateAcceleratorAttributes",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateAcceleratorAttributesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateAcceleratorAttributesResponse, _>()
}
async fn update_custom_routing_accelerator(
&self,
input: UpdateCustomRoutingAcceleratorRequest,
) -> Result<
UpdateCustomRoutingAcceleratorResponse,
RusotoError<UpdateCustomRoutingAcceleratorError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.UpdateCustomRoutingAccelerator",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateCustomRoutingAcceleratorError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateCustomRoutingAcceleratorResponse, _>()
}
async fn update_custom_routing_accelerator_attributes(
&self,
input: UpdateCustomRoutingAcceleratorAttributesRequest,
) -> Result<
UpdateCustomRoutingAcceleratorAttributesResponse,
RusotoError<UpdateCustomRoutingAcceleratorAttributesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.UpdateCustomRoutingAcceleratorAttributes",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
UpdateCustomRoutingAcceleratorAttributesError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateCustomRoutingAcceleratorAttributesResponse, _>()
}
async fn update_custom_routing_listener(
&self,
input: UpdateCustomRoutingListenerRequest,
) -> Result<UpdateCustomRoutingListenerResponse, RusotoError<UpdateCustomRoutingListenerError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.UpdateCustomRoutingListener",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateCustomRoutingListenerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateCustomRoutingListenerResponse, _>()
}
async fn update_endpoint_group(
&self,
input: UpdateEndpointGroupRequest,
) -> Result<UpdateEndpointGroupResponse, RusotoError<UpdateEndpointGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.UpdateEndpointGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateEndpointGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateEndpointGroupResponse, _>()
}
async fn update_listener(
&self,
input: UpdateListenerRequest,
) -> Result<UpdateListenerResponse, RusotoError<UpdateListenerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "GlobalAccelerator_V20180706.UpdateListener");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateListenerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateListenerResponse, _>()
}
async fn withdraw_byoip_cidr(
&self,
input: WithdrawByoipCidrRequest,
) -> Result<WithdrawByoipCidrResponse, RusotoError<WithdrawByoipCidrError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"GlobalAccelerator_V20180706.WithdrawByoipCidr",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, WithdrawByoipCidrError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<WithdrawByoipCidrResponse, _>()
}
}