use std::error::Error;
use std::fmt;
use std::io;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoFuture};
use rusoto_core::credential::{CredentialsError, ProvideAwsCredentials};
use rusoto_core::request::HttpDispatchError;
use rusoto_core::signature::SignedRequest;
use serde_json;
use serde_json::from_slice;
use serde_json::Value as SerdeJsonValue;
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreatePrivateDnsNamespaceRequest {
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Vpc")]
pub vpc: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreatePrivateDnsNamespaceResponse {
#[serde(rename = "OperationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreatePublicDnsNamespaceRequest {
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreatePublicDnsNamespaceResponse {
#[serde(rename = "OperationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateServiceRequest {
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DnsConfig")]
pub dns_config: DnsConfig,
#[serde(rename = "HealthCheckConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_config: Option<HealthCheckConfig>,
#[serde(rename = "HealthCheckCustomConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_custom_config: Option<HealthCheckCustomConfig>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateServiceResponse {
#[serde(rename = "Service")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service: Option<Service>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteNamespaceRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteNamespaceResponse {
#[serde(rename = "OperationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteServiceRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteServiceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeregisterInstanceRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "ServiceId")]
pub service_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeregisterInstanceResponse {
#[serde(rename = "OperationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DnsConfig {
#[serde(rename = "DnsRecords")]
pub dns_records: Vec<DnsRecord>,
#[serde(rename = "NamespaceId")]
pub namespace_id: String,
#[serde(rename = "RoutingPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub routing_policy: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DnsConfigChange {
#[serde(rename = "DnsRecords")]
pub dns_records: Vec<DnsRecord>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DnsProperties {
#[serde(rename = "HostedZoneId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hosted_zone_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DnsRecord {
#[serde(rename = "TTL")]
pub ttl: i64,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetInstanceRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "ServiceId")]
pub service_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetInstanceResponse {
#[serde(rename = "Instance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance: Option<Instance>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetInstancesHealthStatusRequest {
#[serde(rename = "Instances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instances: Option<Vec<String>>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ServiceId")]
pub service_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetInstancesHealthStatusResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetNamespaceRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetNamespaceResponse {
#[serde(rename = "Namespace")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace: Option<Namespace>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetOperationRequest {
#[serde(rename = "OperationId")]
pub operation_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetOperationResponse {
#[serde(rename = "Operation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation: Option<Operation>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetServiceRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetServiceResponse {
#[serde(rename = "Service")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service: Option<Service>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct HealthCheckConfig {
#[serde(rename = "FailureThreshold")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_threshold: Option<i64>,
#[serde(rename = "ResourcePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_path: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct HealthCheckCustomConfig {
#[serde(rename = "FailureThreshold")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_threshold: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Instance {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct InstanceSummary {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListInstancesRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ServiceId")]
pub service_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListInstancesResponse {
#[serde(rename = "Instances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instances: Option<Vec<InstanceSummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListNamespacesRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<NamespaceFilter>>,
#[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(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListNamespacesResponse {
#[serde(rename = "Namespaces")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespaces: Option<Vec<NamespaceSummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListOperationsRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<OperationFilter>>,
#[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(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListOperationsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Operations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operations: Option<Vec<OperationSummary>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListServicesRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<ServiceFilter>>,
#[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(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListServicesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Services")]
#[serde(skip_serializing_if = "Option::is_none")]
pub services: Option<Vec<ServiceSummary>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Namespace {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreateDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_date: Option<f64>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Properties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub properties: Option<NamespaceProperties>,
#[serde(rename = "ServiceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_count: Option<i64>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct NamespaceFilter {
#[serde(rename = "Condition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub condition: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Values")]
pub values: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct NamespaceProperties {
#[serde(rename = "DnsProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dns_properties: Option<DnsProperties>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct NamespaceSummary {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Operation {
#[serde(rename = "CreateDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_date: Option<f64>,
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Targets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub targets: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "UpdateDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_date: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct OperationFilter {
#[serde(rename = "Condition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub condition: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Values")]
pub values: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct OperationSummary {
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RegisterInstanceRequest {
#[serde(rename = "Attributes")]
pub attributes: ::std::collections::HashMap<String, String>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "ServiceId")]
pub service_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RegisterInstanceResponse {
#[serde(rename = "OperationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Service {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreateDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_date: Option<f64>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DnsConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dns_config: Option<DnsConfig>,
#[serde(rename = "HealthCheckConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_config: Option<HealthCheckConfig>,
#[serde(rename = "HealthCheckCustomConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_custom_config: Option<HealthCheckCustomConfig>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "InstanceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_count: Option<i64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ServiceChange {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DnsConfig")]
pub dns_config: DnsConfigChange,
#[serde(rename = "HealthCheckConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_check_config: Option<HealthCheckConfig>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ServiceFilter {
#[serde(rename = "Condition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub condition: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Values")]
pub values: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ServiceSummary {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "InstanceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_count: Option<i64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateInstanceCustomHealthStatusRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "ServiceId")]
pub service_id: String,
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateServiceRequest {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Service")]
pub service: ServiceChange,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateServiceResponse {
#[serde(rename = "OperationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_id: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum CreatePrivateDnsNamespaceError {
DuplicateRequest(String),
InvalidInput(String),
NamespaceAlreadyExists(String),
ResourceLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreatePrivateDnsNamespaceError {
pub fn from_response(res: BufferedHttpResponse) -> CreatePrivateDnsNamespaceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DuplicateRequest" => {
return CreatePrivateDnsNamespaceError::DuplicateRequest(String::from(
error_message,
))
}
"InvalidInput" => {
return CreatePrivateDnsNamespaceError::InvalidInput(String::from(error_message))
}
"NamespaceAlreadyExists" => {
return CreatePrivateDnsNamespaceError::NamespaceAlreadyExists(String::from(
error_message,
))
}
"ResourceLimitExceeded" => {
return CreatePrivateDnsNamespaceError::ResourceLimitExceeded(String::from(
error_message,
))
}
"ValidationException" => {
return CreatePrivateDnsNamespaceError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreatePrivateDnsNamespaceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreatePrivateDnsNamespaceError {
fn from(err: serde_json::error::Error) -> CreatePrivateDnsNamespaceError {
CreatePrivateDnsNamespaceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreatePrivateDnsNamespaceError {
fn from(err: CredentialsError) -> CreatePrivateDnsNamespaceError {
CreatePrivateDnsNamespaceError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreatePrivateDnsNamespaceError {
fn from(err: HttpDispatchError) -> CreatePrivateDnsNamespaceError {
CreatePrivateDnsNamespaceError::HttpDispatch(err)
}
}
impl From<io::Error> for CreatePrivateDnsNamespaceError {
fn from(err: io::Error) -> CreatePrivateDnsNamespaceError {
CreatePrivateDnsNamespaceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreatePrivateDnsNamespaceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreatePrivateDnsNamespaceError {
fn description(&self) -> &str {
match *self {
CreatePrivateDnsNamespaceError::DuplicateRequest(ref cause) => cause,
CreatePrivateDnsNamespaceError::InvalidInput(ref cause) => cause,
CreatePrivateDnsNamespaceError::NamespaceAlreadyExists(ref cause) => cause,
CreatePrivateDnsNamespaceError::ResourceLimitExceeded(ref cause) => cause,
CreatePrivateDnsNamespaceError::Validation(ref cause) => cause,
CreatePrivateDnsNamespaceError::Credentials(ref err) => err.description(),
CreatePrivateDnsNamespaceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreatePrivateDnsNamespaceError::ParseError(ref cause) => cause,
CreatePrivateDnsNamespaceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreatePublicDnsNamespaceError {
DuplicateRequest(String),
InvalidInput(String),
NamespaceAlreadyExists(String),
ResourceLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreatePublicDnsNamespaceError {
pub fn from_response(res: BufferedHttpResponse) -> CreatePublicDnsNamespaceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DuplicateRequest" => {
return CreatePublicDnsNamespaceError::DuplicateRequest(String::from(
error_message,
))
}
"InvalidInput" => {
return CreatePublicDnsNamespaceError::InvalidInput(String::from(error_message))
}
"NamespaceAlreadyExists" => {
return CreatePublicDnsNamespaceError::NamespaceAlreadyExists(String::from(
error_message,
))
}
"ResourceLimitExceeded" => {
return CreatePublicDnsNamespaceError::ResourceLimitExceeded(String::from(
error_message,
))
}
"ValidationException" => {
return CreatePublicDnsNamespaceError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreatePublicDnsNamespaceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreatePublicDnsNamespaceError {
fn from(err: serde_json::error::Error) -> CreatePublicDnsNamespaceError {
CreatePublicDnsNamespaceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreatePublicDnsNamespaceError {
fn from(err: CredentialsError) -> CreatePublicDnsNamespaceError {
CreatePublicDnsNamespaceError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreatePublicDnsNamespaceError {
fn from(err: HttpDispatchError) -> CreatePublicDnsNamespaceError {
CreatePublicDnsNamespaceError::HttpDispatch(err)
}
}
impl From<io::Error> for CreatePublicDnsNamespaceError {
fn from(err: io::Error) -> CreatePublicDnsNamespaceError {
CreatePublicDnsNamespaceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreatePublicDnsNamespaceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreatePublicDnsNamespaceError {
fn description(&self) -> &str {
match *self {
CreatePublicDnsNamespaceError::DuplicateRequest(ref cause) => cause,
CreatePublicDnsNamespaceError::InvalidInput(ref cause) => cause,
CreatePublicDnsNamespaceError::NamespaceAlreadyExists(ref cause) => cause,
CreatePublicDnsNamespaceError::ResourceLimitExceeded(ref cause) => cause,
CreatePublicDnsNamespaceError::Validation(ref cause) => cause,
CreatePublicDnsNamespaceError::Credentials(ref err) => err.description(),
CreatePublicDnsNamespaceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreatePublicDnsNamespaceError::ParseError(ref cause) => cause,
CreatePublicDnsNamespaceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateServiceError {
InvalidInput(String),
NamespaceNotFound(String),
ResourceLimitExceeded(String),
ServiceAlreadyExists(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateServiceError {
pub fn from_response(res: BufferedHttpResponse) -> CreateServiceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidInput" => {
return CreateServiceError::InvalidInput(String::from(error_message))
}
"NamespaceNotFound" => {
return CreateServiceError::NamespaceNotFound(String::from(error_message))
}
"ResourceLimitExceeded" => {
return CreateServiceError::ResourceLimitExceeded(String::from(error_message))
}
"ServiceAlreadyExists" => {
return CreateServiceError::ServiceAlreadyExists(String::from(error_message))
}
"ValidationException" => {
return CreateServiceError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateServiceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateServiceError {
fn from(err: serde_json::error::Error) -> CreateServiceError {
CreateServiceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateServiceError {
fn from(err: CredentialsError) -> CreateServiceError {
CreateServiceError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateServiceError {
fn from(err: HttpDispatchError) -> CreateServiceError {
CreateServiceError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateServiceError {
fn from(err: io::Error) -> CreateServiceError {
CreateServiceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateServiceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateServiceError {
fn description(&self) -> &str {
match *self {
CreateServiceError::InvalidInput(ref cause) => cause,
CreateServiceError::NamespaceNotFound(ref cause) => cause,
CreateServiceError::ResourceLimitExceeded(ref cause) => cause,
CreateServiceError::ServiceAlreadyExists(ref cause) => cause,
CreateServiceError::Validation(ref cause) => cause,
CreateServiceError::Credentials(ref err) => err.description(),
CreateServiceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateServiceError::ParseError(ref cause) => cause,
CreateServiceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteNamespaceError {
DuplicateRequest(String),
InvalidInput(String),
NamespaceNotFound(String),
ResourceInUse(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteNamespaceError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteNamespaceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DuplicateRequest" => {
return DeleteNamespaceError::DuplicateRequest(String::from(error_message))
}
"InvalidInput" => {
return DeleteNamespaceError::InvalidInput(String::from(error_message))
}
"NamespaceNotFound" => {
return DeleteNamespaceError::NamespaceNotFound(String::from(error_message))
}
"ResourceInUse" => {
return DeleteNamespaceError::ResourceInUse(String::from(error_message))
}
"ValidationException" => {
return DeleteNamespaceError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteNamespaceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteNamespaceError {
fn from(err: serde_json::error::Error) -> DeleteNamespaceError {
DeleteNamespaceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteNamespaceError {
fn from(err: CredentialsError) -> DeleteNamespaceError {
DeleteNamespaceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteNamespaceError {
fn from(err: HttpDispatchError) -> DeleteNamespaceError {
DeleteNamespaceError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteNamespaceError {
fn from(err: io::Error) -> DeleteNamespaceError {
DeleteNamespaceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteNamespaceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteNamespaceError {
fn description(&self) -> &str {
match *self {
DeleteNamespaceError::DuplicateRequest(ref cause) => cause,
DeleteNamespaceError::InvalidInput(ref cause) => cause,
DeleteNamespaceError::NamespaceNotFound(ref cause) => cause,
DeleteNamespaceError::ResourceInUse(ref cause) => cause,
DeleteNamespaceError::Validation(ref cause) => cause,
DeleteNamespaceError::Credentials(ref err) => err.description(),
DeleteNamespaceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteNamespaceError::ParseError(ref cause) => cause,
DeleteNamespaceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteServiceError {
InvalidInput(String),
ResourceInUse(String),
ServiceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteServiceError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteServiceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidInput" => {
return DeleteServiceError::InvalidInput(String::from(error_message))
}
"ResourceInUse" => {
return DeleteServiceError::ResourceInUse(String::from(error_message))
}
"ServiceNotFound" => {
return DeleteServiceError::ServiceNotFound(String::from(error_message))
}
"ValidationException" => {
return DeleteServiceError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteServiceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteServiceError {
fn from(err: serde_json::error::Error) -> DeleteServiceError {
DeleteServiceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteServiceError {
fn from(err: CredentialsError) -> DeleteServiceError {
DeleteServiceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteServiceError {
fn from(err: HttpDispatchError) -> DeleteServiceError {
DeleteServiceError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteServiceError {
fn from(err: io::Error) -> DeleteServiceError {
DeleteServiceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteServiceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteServiceError {
fn description(&self) -> &str {
match *self {
DeleteServiceError::InvalidInput(ref cause) => cause,
DeleteServiceError::ResourceInUse(ref cause) => cause,
DeleteServiceError::ServiceNotFound(ref cause) => cause,
DeleteServiceError::Validation(ref cause) => cause,
DeleteServiceError::Credentials(ref err) => err.description(),
DeleteServiceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteServiceError::ParseError(ref cause) => cause,
DeleteServiceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeregisterInstanceError {
DuplicateRequest(String),
InstanceNotFound(String),
InvalidInput(String),
ResourceInUse(String),
ServiceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeregisterInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> DeregisterInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DuplicateRequest" => {
return DeregisterInstanceError::DuplicateRequest(String::from(error_message))
}
"InstanceNotFound" => {
return DeregisterInstanceError::InstanceNotFound(String::from(error_message))
}
"InvalidInput" => {
return DeregisterInstanceError::InvalidInput(String::from(error_message))
}
"ResourceInUse" => {
return DeregisterInstanceError::ResourceInUse(String::from(error_message))
}
"ServiceNotFound" => {
return DeregisterInstanceError::ServiceNotFound(String::from(error_message))
}
"ValidationException" => {
return DeregisterInstanceError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeregisterInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeregisterInstanceError {
fn from(err: serde_json::error::Error) -> DeregisterInstanceError {
DeregisterInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeregisterInstanceError {
fn from(err: CredentialsError) -> DeregisterInstanceError {
DeregisterInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeregisterInstanceError {
fn from(err: HttpDispatchError) -> DeregisterInstanceError {
DeregisterInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for DeregisterInstanceError {
fn from(err: io::Error) -> DeregisterInstanceError {
DeregisterInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeregisterInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeregisterInstanceError {
fn description(&self) -> &str {
match *self {
DeregisterInstanceError::DuplicateRequest(ref cause) => cause,
DeregisterInstanceError::InstanceNotFound(ref cause) => cause,
DeregisterInstanceError::InvalidInput(ref cause) => cause,
DeregisterInstanceError::ResourceInUse(ref cause) => cause,
DeregisterInstanceError::ServiceNotFound(ref cause) => cause,
DeregisterInstanceError::Validation(ref cause) => cause,
DeregisterInstanceError::Credentials(ref err) => err.description(),
DeregisterInstanceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeregisterInstanceError::ParseError(ref cause) => cause,
DeregisterInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetInstanceError {
InstanceNotFound(String),
InvalidInput(String),
ServiceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> GetInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InstanceNotFound" => {
return GetInstanceError::InstanceNotFound(String::from(error_message))
}
"InvalidInput" => {
return GetInstanceError::InvalidInput(String::from(error_message))
}
"ServiceNotFound" => {
return GetInstanceError::ServiceNotFound(String::from(error_message))
}
"ValidationException" => {
return GetInstanceError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetInstanceError {
fn from(err: serde_json::error::Error) -> GetInstanceError {
GetInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetInstanceError {
fn from(err: CredentialsError) -> GetInstanceError {
GetInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetInstanceError {
fn from(err: HttpDispatchError) -> GetInstanceError {
GetInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for GetInstanceError {
fn from(err: io::Error) -> GetInstanceError {
GetInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetInstanceError {
fn description(&self) -> &str {
match *self {
GetInstanceError::InstanceNotFound(ref cause) => cause,
GetInstanceError::InvalidInput(ref cause) => cause,
GetInstanceError::ServiceNotFound(ref cause) => cause,
GetInstanceError::Validation(ref cause) => cause,
GetInstanceError::Credentials(ref err) => err.description(),
GetInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetInstanceError::ParseError(ref cause) => cause,
GetInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetInstancesHealthStatusError {
InstanceNotFound(String),
InvalidInput(String),
ServiceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetInstancesHealthStatusError {
pub fn from_response(res: BufferedHttpResponse) -> GetInstancesHealthStatusError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InstanceNotFound" => {
return GetInstancesHealthStatusError::InstanceNotFound(String::from(
error_message,
))
}
"InvalidInput" => {
return GetInstancesHealthStatusError::InvalidInput(String::from(error_message))
}
"ServiceNotFound" => {
return GetInstancesHealthStatusError::ServiceNotFound(String::from(
error_message,
))
}
"ValidationException" => {
return GetInstancesHealthStatusError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetInstancesHealthStatusError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetInstancesHealthStatusError {
fn from(err: serde_json::error::Error) -> GetInstancesHealthStatusError {
GetInstancesHealthStatusError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetInstancesHealthStatusError {
fn from(err: CredentialsError) -> GetInstancesHealthStatusError {
GetInstancesHealthStatusError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetInstancesHealthStatusError {
fn from(err: HttpDispatchError) -> GetInstancesHealthStatusError {
GetInstancesHealthStatusError::HttpDispatch(err)
}
}
impl From<io::Error> for GetInstancesHealthStatusError {
fn from(err: io::Error) -> GetInstancesHealthStatusError {
GetInstancesHealthStatusError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetInstancesHealthStatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetInstancesHealthStatusError {
fn description(&self) -> &str {
match *self {
GetInstancesHealthStatusError::InstanceNotFound(ref cause) => cause,
GetInstancesHealthStatusError::InvalidInput(ref cause) => cause,
GetInstancesHealthStatusError::ServiceNotFound(ref cause) => cause,
GetInstancesHealthStatusError::Validation(ref cause) => cause,
GetInstancesHealthStatusError::Credentials(ref err) => err.description(),
GetInstancesHealthStatusError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetInstancesHealthStatusError::ParseError(ref cause) => cause,
GetInstancesHealthStatusError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetNamespaceError {
InvalidInput(String),
NamespaceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetNamespaceError {
pub fn from_response(res: BufferedHttpResponse) -> GetNamespaceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidInput" => {
return GetNamespaceError::InvalidInput(String::from(error_message))
}
"NamespaceNotFound" => {
return GetNamespaceError::NamespaceNotFound(String::from(error_message))
}
"ValidationException" => {
return GetNamespaceError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetNamespaceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetNamespaceError {
fn from(err: serde_json::error::Error) -> GetNamespaceError {
GetNamespaceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetNamespaceError {
fn from(err: CredentialsError) -> GetNamespaceError {
GetNamespaceError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetNamespaceError {
fn from(err: HttpDispatchError) -> GetNamespaceError {
GetNamespaceError::HttpDispatch(err)
}
}
impl From<io::Error> for GetNamespaceError {
fn from(err: io::Error) -> GetNamespaceError {
GetNamespaceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetNamespaceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetNamespaceError {
fn description(&self) -> &str {
match *self {
GetNamespaceError::InvalidInput(ref cause) => cause,
GetNamespaceError::NamespaceNotFound(ref cause) => cause,
GetNamespaceError::Validation(ref cause) => cause,
GetNamespaceError::Credentials(ref err) => err.description(),
GetNamespaceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetNamespaceError::ParseError(ref cause) => cause,
GetNamespaceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetOperationError {
OperationNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetOperationError {
pub fn from_response(res: BufferedHttpResponse) -> GetOperationError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"OperationNotFound" => {
return GetOperationError::OperationNotFound(String::from(error_message))
}
"ValidationException" => {
return GetOperationError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetOperationError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetOperationError {
fn from(err: serde_json::error::Error) -> GetOperationError {
GetOperationError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetOperationError {
fn from(err: CredentialsError) -> GetOperationError {
GetOperationError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetOperationError {
fn from(err: HttpDispatchError) -> GetOperationError {
GetOperationError::HttpDispatch(err)
}
}
impl From<io::Error> for GetOperationError {
fn from(err: io::Error) -> GetOperationError {
GetOperationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetOperationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetOperationError {
fn description(&self) -> &str {
match *self {
GetOperationError::OperationNotFound(ref cause) => cause,
GetOperationError::Validation(ref cause) => cause,
GetOperationError::Credentials(ref err) => err.description(),
GetOperationError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetOperationError::ParseError(ref cause) => cause,
GetOperationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetServiceError {
InvalidInput(String),
ServiceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetServiceError {
pub fn from_response(res: BufferedHttpResponse) -> GetServiceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidInput" => return GetServiceError::InvalidInput(String::from(error_message)),
"ServiceNotFound" => {
return GetServiceError::ServiceNotFound(String::from(error_message))
}
"ValidationException" => {
return GetServiceError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetServiceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetServiceError {
fn from(err: serde_json::error::Error) -> GetServiceError {
GetServiceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetServiceError {
fn from(err: CredentialsError) -> GetServiceError {
GetServiceError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetServiceError {
fn from(err: HttpDispatchError) -> GetServiceError {
GetServiceError::HttpDispatch(err)
}
}
impl From<io::Error> for GetServiceError {
fn from(err: io::Error) -> GetServiceError {
GetServiceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetServiceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetServiceError {
fn description(&self) -> &str {
match *self {
GetServiceError::InvalidInput(ref cause) => cause,
GetServiceError::ServiceNotFound(ref cause) => cause,
GetServiceError::Validation(ref cause) => cause,
GetServiceError::Credentials(ref err) => err.description(),
GetServiceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetServiceError::ParseError(ref cause) => cause,
GetServiceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListInstancesError {
InvalidInput(String),
ServiceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> ListInstancesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidInput" => {
return ListInstancesError::InvalidInput(String::from(error_message))
}
"ServiceNotFound" => {
return ListInstancesError::ServiceNotFound(String::from(error_message))
}
"ValidationException" => {
return ListInstancesError::Validation(error_message.to_string())
}
_ => {}
}
}
return ListInstancesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListInstancesError {
fn from(err: serde_json::error::Error) -> ListInstancesError {
ListInstancesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListInstancesError {
fn from(err: CredentialsError) -> ListInstancesError {
ListInstancesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListInstancesError {
fn from(err: HttpDispatchError) -> ListInstancesError {
ListInstancesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListInstancesError {
fn from(err: io::Error) -> ListInstancesError {
ListInstancesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListInstancesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListInstancesError {
fn description(&self) -> &str {
match *self {
ListInstancesError::InvalidInput(ref cause) => cause,
ListInstancesError::ServiceNotFound(ref cause) => cause,
ListInstancesError::Validation(ref cause) => cause,
ListInstancesError::Credentials(ref err) => err.description(),
ListInstancesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListInstancesError::ParseError(ref cause) => cause,
ListInstancesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListNamespacesError {
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListNamespacesError {
pub fn from_response(res: BufferedHttpResponse) -> ListNamespacesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidInput" => {
return ListNamespacesError::InvalidInput(String::from(error_message))
}
"ValidationException" => {
return ListNamespacesError::Validation(error_message.to_string())
}
_ => {}
}
}
return ListNamespacesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListNamespacesError {
fn from(err: serde_json::error::Error) -> ListNamespacesError {
ListNamespacesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListNamespacesError {
fn from(err: CredentialsError) -> ListNamespacesError {
ListNamespacesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListNamespacesError {
fn from(err: HttpDispatchError) -> ListNamespacesError {
ListNamespacesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListNamespacesError {
fn from(err: io::Error) -> ListNamespacesError {
ListNamespacesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListNamespacesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListNamespacesError {
fn description(&self) -> &str {
match *self {
ListNamespacesError::InvalidInput(ref cause) => cause,
ListNamespacesError::Validation(ref cause) => cause,
ListNamespacesError::Credentials(ref err) => err.description(),
ListNamespacesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListNamespacesError::ParseError(ref cause) => cause,
ListNamespacesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListOperationsError {
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListOperationsError {
pub fn from_response(res: BufferedHttpResponse) -> ListOperationsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidInput" => {
return ListOperationsError::InvalidInput(String::from(error_message))
}
"ValidationException" => {
return ListOperationsError::Validation(error_message.to_string())
}
_ => {}
}
}
return ListOperationsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListOperationsError {
fn from(err: serde_json::error::Error) -> ListOperationsError {
ListOperationsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListOperationsError {
fn from(err: CredentialsError) -> ListOperationsError {
ListOperationsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListOperationsError {
fn from(err: HttpDispatchError) -> ListOperationsError {
ListOperationsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListOperationsError {
fn from(err: io::Error) -> ListOperationsError {
ListOperationsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListOperationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListOperationsError {
fn description(&self) -> &str {
match *self {
ListOperationsError::InvalidInput(ref cause) => cause,
ListOperationsError::Validation(ref cause) => cause,
ListOperationsError::Credentials(ref err) => err.description(),
ListOperationsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListOperationsError::ParseError(ref cause) => cause,
ListOperationsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListServicesError {
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListServicesError {
pub fn from_response(res: BufferedHttpResponse) -> ListServicesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidInput" => {
return ListServicesError::InvalidInput(String::from(error_message))
}
"ValidationException" => {
return ListServicesError::Validation(error_message.to_string())
}
_ => {}
}
}
return ListServicesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListServicesError {
fn from(err: serde_json::error::Error) -> ListServicesError {
ListServicesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListServicesError {
fn from(err: CredentialsError) -> ListServicesError {
ListServicesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListServicesError {
fn from(err: HttpDispatchError) -> ListServicesError {
ListServicesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListServicesError {
fn from(err: io::Error) -> ListServicesError {
ListServicesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListServicesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListServicesError {
fn description(&self) -> &str {
match *self {
ListServicesError::InvalidInput(ref cause) => cause,
ListServicesError::Validation(ref cause) => cause,
ListServicesError::Credentials(ref err) => err.description(),
ListServicesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListServicesError::ParseError(ref cause) => cause,
ListServicesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RegisterInstanceError {
DuplicateRequest(String),
InvalidInput(String),
ResourceInUse(String),
ResourceLimitExceeded(String),
ServiceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RegisterInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RegisterInstanceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DuplicateRequest" => {
return RegisterInstanceError::DuplicateRequest(String::from(error_message))
}
"InvalidInput" => {
return RegisterInstanceError::InvalidInput(String::from(error_message))
}
"ResourceInUse" => {
return RegisterInstanceError::ResourceInUse(String::from(error_message))
}
"ResourceLimitExceeded" => {
return RegisterInstanceError::ResourceLimitExceeded(String::from(error_message))
}
"ServiceNotFound" => {
return RegisterInstanceError::ServiceNotFound(String::from(error_message))
}
"ValidationException" => {
return RegisterInstanceError::Validation(error_message.to_string())
}
_ => {}
}
}
return RegisterInstanceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RegisterInstanceError {
fn from(err: serde_json::error::Error) -> RegisterInstanceError {
RegisterInstanceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RegisterInstanceError {
fn from(err: CredentialsError) -> RegisterInstanceError {
RegisterInstanceError::Credentials(err)
}
}
impl From<HttpDispatchError> for RegisterInstanceError {
fn from(err: HttpDispatchError) -> RegisterInstanceError {
RegisterInstanceError::HttpDispatch(err)
}
}
impl From<io::Error> for RegisterInstanceError {
fn from(err: io::Error) -> RegisterInstanceError {
RegisterInstanceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RegisterInstanceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RegisterInstanceError {
fn description(&self) -> &str {
match *self {
RegisterInstanceError::DuplicateRequest(ref cause) => cause,
RegisterInstanceError::InvalidInput(ref cause) => cause,
RegisterInstanceError::ResourceInUse(ref cause) => cause,
RegisterInstanceError::ResourceLimitExceeded(ref cause) => cause,
RegisterInstanceError::ServiceNotFound(ref cause) => cause,
RegisterInstanceError::Validation(ref cause) => cause,
RegisterInstanceError::Credentials(ref err) => err.description(),
RegisterInstanceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
RegisterInstanceError::ParseError(ref cause) => cause,
RegisterInstanceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateInstanceCustomHealthStatusError {
CustomHealthNotFound(String),
InstanceNotFound(String),
InvalidInput(String),
ServiceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateInstanceCustomHealthStatusError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateInstanceCustomHealthStatusError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"CustomHealthNotFound" => {
return UpdateInstanceCustomHealthStatusError::CustomHealthNotFound(
String::from(error_message),
)
}
"InstanceNotFound" => {
return UpdateInstanceCustomHealthStatusError::InstanceNotFound(String::from(
error_message,
))
}
"InvalidInput" => {
return UpdateInstanceCustomHealthStatusError::InvalidInput(String::from(
error_message,
))
}
"ServiceNotFound" => {
return UpdateInstanceCustomHealthStatusError::ServiceNotFound(String::from(
error_message,
))
}
"ValidationException" => {
return UpdateInstanceCustomHealthStatusError::Validation(
error_message.to_string(),
)
}
_ => {}
}
}
return UpdateInstanceCustomHealthStatusError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateInstanceCustomHealthStatusError {
fn from(err: serde_json::error::Error) -> UpdateInstanceCustomHealthStatusError {
UpdateInstanceCustomHealthStatusError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateInstanceCustomHealthStatusError {
fn from(err: CredentialsError) -> UpdateInstanceCustomHealthStatusError {
UpdateInstanceCustomHealthStatusError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateInstanceCustomHealthStatusError {
fn from(err: HttpDispatchError) -> UpdateInstanceCustomHealthStatusError {
UpdateInstanceCustomHealthStatusError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateInstanceCustomHealthStatusError {
fn from(err: io::Error) -> UpdateInstanceCustomHealthStatusError {
UpdateInstanceCustomHealthStatusError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateInstanceCustomHealthStatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateInstanceCustomHealthStatusError {
fn description(&self) -> &str {
match *self {
UpdateInstanceCustomHealthStatusError::CustomHealthNotFound(ref cause) => cause,
UpdateInstanceCustomHealthStatusError::InstanceNotFound(ref cause) => cause,
UpdateInstanceCustomHealthStatusError::InvalidInput(ref cause) => cause,
UpdateInstanceCustomHealthStatusError::ServiceNotFound(ref cause) => cause,
UpdateInstanceCustomHealthStatusError::Validation(ref cause) => cause,
UpdateInstanceCustomHealthStatusError::Credentials(ref err) => err.description(),
UpdateInstanceCustomHealthStatusError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateInstanceCustomHealthStatusError::ParseError(ref cause) => cause,
UpdateInstanceCustomHealthStatusError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateServiceError {
DuplicateRequest(String),
InvalidInput(String),
ServiceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateServiceError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateServiceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DuplicateRequest" => {
return UpdateServiceError::DuplicateRequest(String::from(error_message))
}
"InvalidInput" => {
return UpdateServiceError::InvalidInput(String::from(error_message))
}
"ServiceNotFound" => {
return UpdateServiceError::ServiceNotFound(String::from(error_message))
}
"ValidationException" => {
return UpdateServiceError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateServiceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateServiceError {
fn from(err: serde_json::error::Error) -> UpdateServiceError {
UpdateServiceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateServiceError {
fn from(err: CredentialsError) -> UpdateServiceError {
UpdateServiceError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateServiceError {
fn from(err: HttpDispatchError) -> UpdateServiceError {
UpdateServiceError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateServiceError {
fn from(err: io::Error) -> UpdateServiceError {
UpdateServiceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateServiceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateServiceError {
fn description(&self) -> &str {
match *self {
UpdateServiceError::DuplicateRequest(ref cause) => cause,
UpdateServiceError::InvalidInput(ref cause) => cause,
UpdateServiceError::ServiceNotFound(ref cause) => cause,
UpdateServiceError::Validation(ref cause) => cause,
UpdateServiceError::Credentials(ref err) => err.description(),
UpdateServiceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateServiceError::ParseError(ref cause) => cause,
UpdateServiceError::Unknown(_) => "unknown error",
}
}
}
pub trait ServiceDiscovery {
fn create_private_dns_namespace(
&self,
input: CreatePrivateDnsNamespaceRequest,
) -> RusotoFuture<CreatePrivateDnsNamespaceResponse, CreatePrivateDnsNamespaceError>;
fn create_public_dns_namespace(
&self,
input: CreatePublicDnsNamespaceRequest,
) -> RusotoFuture<CreatePublicDnsNamespaceResponse, CreatePublicDnsNamespaceError>;
fn create_service(
&self,
input: CreateServiceRequest,
) -> RusotoFuture<CreateServiceResponse, CreateServiceError>;
fn delete_namespace(
&self,
input: DeleteNamespaceRequest,
) -> RusotoFuture<DeleteNamespaceResponse, DeleteNamespaceError>;
fn delete_service(
&self,
input: DeleteServiceRequest,
) -> RusotoFuture<DeleteServiceResponse, DeleteServiceError>;
fn deregister_instance(
&self,
input: DeregisterInstanceRequest,
) -> RusotoFuture<DeregisterInstanceResponse, DeregisterInstanceError>;
fn get_instance(
&self,
input: GetInstanceRequest,
) -> RusotoFuture<GetInstanceResponse, GetInstanceError>;
fn get_instances_health_status(
&self,
input: GetInstancesHealthStatusRequest,
) -> RusotoFuture<GetInstancesHealthStatusResponse, GetInstancesHealthStatusError>;
fn get_namespace(
&self,
input: GetNamespaceRequest,
) -> RusotoFuture<GetNamespaceResponse, GetNamespaceError>;
fn get_operation(
&self,
input: GetOperationRequest,
) -> RusotoFuture<GetOperationResponse, GetOperationError>;
fn get_service(
&self,
input: GetServiceRequest,
) -> RusotoFuture<GetServiceResponse, GetServiceError>;
fn list_instances(
&self,
input: ListInstancesRequest,
) -> RusotoFuture<ListInstancesResponse, ListInstancesError>;
fn list_namespaces(
&self,
input: ListNamespacesRequest,
) -> RusotoFuture<ListNamespacesResponse, ListNamespacesError>;
fn list_operations(
&self,
input: ListOperationsRequest,
) -> RusotoFuture<ListOperationsResponse, ListOperationsError>;
fn list_services(
&self,
input: ListServicesRequest,
) -> RusotoFuture<ListServicesResponse, ListServicesError>;
fn register_instance(
&self,
input: RegisterInstanceRequest,
) -> RusotoFuture<RegisterInstanceResponse, RegisterInstanceError>;
fn update_instance_custom_health_status(
&self,
input: UpdateInstanceCustomHealthStatusRequest,
) -> RusotoFuture<(), UpdateInstanceCustomHealthStatusError>;
fn update_service(
&self,
input: UpdateServiceRequest,
) -> RusotoFuture<UpdateServiceResponse, UpdateServiceError>;
}
pub struct ServiceDiscoveryClient {
client: Client,
region: region::Region,
}
impl ServiceDiscoveryClient {
pub fn new(region: region::Region) -> ServiceDiscoveryClient {
ServiceDiscoveryClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ServiceDiscoveryClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
ServiceDiscoveryClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl ServiceDiscovery for ServiceDiscoveryClient {
fn create_private_dns_namespace(
&self,
input: CreatePrivateDnsNamespaceRequest,
) -> RusotoFuture<CreatePrivateDnsNamespaceResponse, CreatePrivateDnsNamespaceError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"Route53AutoNaming_v20170314.CreatePrivateDnsNamespace",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreatePrivateDnsNamespaceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreatePrivateDnsNamespaceError::from_response(response))
}))
}
})
}
fn create_public_dns_namespace(
&self,
input: CreatePublicDnsNamespaceRequest,
) -> RusotoFuture<CreatePublicDnsNamespaceResponse, CreatePublicDnsNamespaceError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"Route53AutoNaming_v20170314.CreatePublicDnsNamespace",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreatePublicDnsNamespaceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreatePublicDnsNamespaceError::from_response(response))
}))
}
})
}
fn create_service(
&self,
input: CreateServiceRequest,
) -> RusotoFuture<CreateServiceResponse, CreateServiceError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53AutoNaming_v20170314.CreateService");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateServiceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateServiceError::from_response(response))),
)
}
})
}
fn delete_namespace(
&self,
input: DeleteNamespaceRequest,
) -> RusotoFuture<DeleteNamespaceResponse, DeleteNamespaceError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"Route53AutoNaming_v20170314.DeleteNamespace",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteNamespaceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteNamespaceError::from_response(response))),
)
}
})
}
fn delete_service(
&self,
input: DeleteServiceRequest,
) -> RusotoFuture<DeleteServiceResponse, DeleteServiceError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53AutoNaming_v20170314.DeleteService");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteServiceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteServiceError::from_response(response))),
)
}
})
}
fn deregister_instance(
&self,
input: DeregisterInstanceRequest,
) -> RusotoFuture<DeregisterInstanceResponse, DeregisterInstanceError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"Route53AutoNaming_v20170314.DeregisterInstance",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeregisterInstanceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeregisterInstanceError::from_response(response))),
)
}
})
}
fn get_instance(
&self,
input: GetInstanceRequest,
) -> RusotoFuture<GetInstanceResponse, GetInstanceError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53AutoNaming_v20170314.GetInstance");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<GetInstanceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetInstanceError::from_response(response))),
)
}
})
}
fn get_instances_health_status(
&self,
input: GetInstancesHealthStatusRequest,
) -> RusotoFuture<GetInstancesHealthStatusResponse, GetInstancesHealthStatusError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"Route53AutoNaming_v20170314.GetInstancesHealthStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<GetInstancesHealthStatusResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetInstancesHealthStatusError::from_response(response))
}))
}
})
}
fn get_namespace(
&self,
input: GetNamespaceRequest,
) -> RusotoFuture<GetNamespaceResponse, GetNamespaceError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53AutoNaming_v20170314.GetNamespace");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<GetNamespaceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetNamespaceError::from_response(response))),
)
}
})
}
fn get_operation(
&self,
input: GetOperationRequest,
) -> RusotoFuture<GetOperationResponse, GetOperationError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53AutoNaming_v20170314.GetOperation");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<GetOperationResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetOperationError::from_response(response))),
)
}
})
}
fn get_service(
&self,
input: GetServiceRequest,
) -> RusotoFuture<GetServiceResponse, GetServiceError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53AutoNaming_v20170314.GetService");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<GetServiceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetServiceError::from_response(response))),
)
}
})
}
fn list_instances(
&self,
input: ListInstancesRequest,
) -> RusotoFuture<ListInstancesResponse, ListInstancesError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53AutoNaming_v20170314.ListInstances");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListInstancesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListInstancesError::from_response(response))),
)
}
})
}
fn list_namespaces(
&self,
input: ListNamespacesRequest,
) -> RusotoFuture<ListNamespacesResponse, ListNamespacesError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53AutoNaming_v20170314.ListNamespaces");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListNamespacesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListNamespacesError::from_response(response))),
)
}
})
}
fn list_operations(
&self,
input: ListOperationsRequest,
) -> RusotoFuture<ListOperationsResponse, ListOperationsError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53AutoNaming_v20170314.ListOperations");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListOperationsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListOperationsError::from_response(response))),
)
}
})
}
fn list_services(
&self,
input: ListServicesRequest,
) -> RusotoFuture<ListServicesResponse, ListServicesError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53AutoNaming_v20170314.ListServices");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListServicesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListServicesError::from_response(response))),
)
}
})
}
fn register_instance(
&self,
input: RegisterInstanceRequest,
) -> RusotoFuture<RegisterInstanceResponse, RegisterInstanceError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"Route53AutoNaming_v20170314.RegisterInstance",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<RegisterInstanceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RegisterInstanceError::from_response(response))),
)
}
})
}
fn update_instance_custom_health_status(
&self,
input: UpdateInstanceCustomHealthStatusRequest,
) -> RusotoFuture<(), UpdateInstanceCustomHealthStatusError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"Route53AutoNaming_v20170314.UpdateInstanceCustomHealthStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateInstanceCustomHealthStatusError::from_response(
response,
))
}))
}
})
}
fn update_service(
&self,
input: UpdateServiceRequest,
) -> RusotoFuture<UpdateServiceResponse, UpdateServiceError> {
let mut request = SignedRequest::new("POST", "servicediscovery", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53AutoNaming_v20170314.UpdateService");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<UpdateServiceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateServiceError::from_response(response))),
)
}
})
}
}
#[cfg(test)]
mod protocol_tests {}