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 AddTagsToCertificateRequest {
#[serde(rename = "CertificateArn")]
pub certificate_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CertificateDetail {
#[serde(rename = "CertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
#[serde(rename = "CertificateAuthorityArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_authority_arn: Option<String>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "DomainValidationOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_validation_options: Option<Vec<DomainValidation>>,
#[serde(rename = "ExtendedKeyUsages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extended_key_usages: Option<Vec<ExtendedKeyUsage>>,
#[serde(rename = "FailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "ImportedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub imported_at: Option<f64>,
#[serde(rename = "InUseBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub in_use_by: Option<Vec<String>>,
#[serde(rename = "IssuedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub issued_at: Option<f64>,
#[serde(rename = "Issuer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<String>,
#[serde(rename = "KeyAlgorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_algorithm: Option<String>,
#[serde(rename = "KeyUsages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_usages: Option<Vec<KeyUsage>>,
#[serde(rename = "NotAfter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub not_after: Option<f64>,
#[serde(rename = "NotBefore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub not_before: Option<f64>,
#[serde(rename = "Options")]
#[serde(skip_serializing_if = "Option::is_none")]
pub options: Option<CertificateOptions>,
#[serde(rename = "RenewalEligibility")]
#[serde(skip_serializing_if = "Option::is_none")]
pub renewal_eligibility: Option<String>,
#[serde(rename = "RenewalSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub renewal_summary: Option<RenewalSummary>,
#[serde(rename = "RevocationReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revocation_reason: Option<String>,
#[serde(rename = "RevokedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revoked_at: Option<f64>,
#[serde(rename = "Serial")]
#[serde(skip_serializing_if = "Option::is_none")]
pub serial: Option<String>,
#[serde(rename = "SignatureAlgorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signature_algorithm: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Subject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subject: Option<String>,
#[serde(rename = "SubjectAlternativeNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subject_alternative_names: Option<Vec<String>>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CertificateOptions {
#[serde(rename = "CertificateTransparencyLoggingPreference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_transparency_logging_preference: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CertificateSummary {
#[serde(rename = "CertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteCertificateRequest {
#[serde(rename = "CertificateArn")]
pub certificate_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeCertificateRequest {
#[serde(rename = "CertificateArn")]
pub certificate_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeCertificateResponse {
#[serde(rename = "Certificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate: Option<CertificateDetail>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DomainValidation {
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "ResourceRecord")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_record: Option<ResourceRecord>,
#[serde(rename = "ValidationDomain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_domain: Option<String>,
#[serde(rename = "ValidationEmails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_emails: Option<Vec<String>>,
#[serde(rename = "ValidationMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_method: Option<String>,
#[serde(rename = "ValidationStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DomainValidationOption {
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "ValidationDomain")]
pub validation_domain: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ExportCertificateRequest {
#[serde(rename = "CertificateArn")]
pub certificate_arn: String,
#[serde(rename = "Passphrase")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
pub passphrase: Vec<u8>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ExportCertificateResponse {
#[serde(rename = "Certificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate: Option<String>,
#[serde(rename = "CertificateChain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_chain: Option<String>,
#[serde(rename = "PrivateKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_key: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ExtendedKeyUsage {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "OID")]
#[serde(skip_serializing_if = "Option::is_none")]
pub oid: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct Filters {
#[serde(rename = "extendedKeyUsage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extended_key_usage: Option<Vec<String>>,
#[serde(rename = "keyTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_types: Option<Vec<String>>,
#[serde(rename = "keyUsage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_usage: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetCertificateRequest {
#[serde(rename = "CertificateArn")]
pub certificate_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetCertificateResponse {
#[serde(rename = "Certificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate: Option<String>,
#[serde(rename = "CertificateChain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_chain: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ImportCertificateRequest {
#[serde(rename = "Certificate")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
pub certificate: Vec<u8>,
#[serde(rename = "CertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
#[serde(rename = "CertificateChain")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_chain: Option<Vec<u8>>,
#[serde(rename = "PrivateKey")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
pub private_key: Vec<u8>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ImportCertificateResponse {
#[serde(rename = "CertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct KeyUsage {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListCertificatesRequest {
#[serde(rename = "CertificateStatuses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_statuses: Option<Vec<String>>,
#[serde(rename = "Includes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub includes: Option<Filters>,
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: 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 ListCertificatesResponse {
#[serde(rename = "CertificateSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_summary_list: Option<Vec<CertificateSummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListTagsForCertificateRequest {
#[serde(rename = "CertificateArn")]
pub certificate_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListTagsForCertificateResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RemoveTagsFromCertificateRequest {
#[serde(rename = "CertificateArn")]
pub certificate_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RenewalSummary {
#[serde(rename = "DomainValidationOptions")]
pub domain_validation_options: Vec<DomainValidation>,
#[serde(rename = "RenewalStatus")]
pub renewal_status: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RequestCertificateRequest {
#[serde(rename = "CertificateAuthorityArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_authority_arn: Option<String>,
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "DomainValidationOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_validation_options: Option<Vec<DomainValidationOption>>,
#[serde(rename = "IdempotencyToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub idempotency_token: Option<String>,
#[serde(rename = "Options")]
#[serde(skip_serializing_if = "Option::is_none")]
pub options: Option<CertificateOptions>,
#[serde(rename = "SubjectAlternativeNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subject_alternative_names: Option<Vec<String>>,
#[serde(rename = "ValidationMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_method: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RequestCertificateResponse {
#[serde(rename = "CertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ResendValidationEmailRequest {
#[serde(rename = "CertificateArn")]
pub certificate_arn: String,
#[serde(rename = "Domain")]
pub domain: String,
#[serde(rename = "ValidationDomain")]
pub validation_domain: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ResourceRecord {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Type")]
pub type_: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Tag {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateCertificateOptionsRequest {
#[serde(rename = "CertificateArn")]
pub certificate_arn: String,
#[serde(rename = "Options")]
pub options: CertificateOptions,
}
#[derive(Debug, PartialEq)]
pub enum AddTagsToCertificateError {
InvalidArn(String),
InvalidTag(String),
ResourceNotFound(String),
TooManyTags(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AddTagsToCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> AddTagsToCertificateError {
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 {
"InvalidArnException" => {
return AddTagsToCertificateError::InvalidArn(String::from(error_message));
}
"InvalidTagException" => {
return AddTagsToCertificateError::InvalidTag(String::from(error_message));
}
"ResourceNotFoundException" => {
return AddTagsToCertificateError::ResourceNotFound(String::from(error_message));
}
"TooManyTagsException" => {
return AddTagsToCertificateError::TooManyTags(String::from(error_message));
}
"ValidationException" => {
return AddTagsToCertificateError::Validation(error_message.to_string());
}
_ => {}
}
}
return AddTagsToCertificateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AddTagsToCertificateError {
fn from(err: serde_json::error::Error) -> AddTagsToCertificateError {
AddTagsToCertificateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AddTagsToCertificateError {
fn from(err: CredentialsError) -> AddTagsToCertificateError {
AddTagsToCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for AddTagsToCertificateError {
fn from(err: HttpDispatchError) -> AddTagsToCertificateError {
AddTagsToCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for AddTagsToCertificateError {
fn from(err: io::Error) -> AddTagsToCertificateError {
AddTagsToCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AddTagsToCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AddTagsToCertificateError {
fn description(&self) -> &str {
match *self {
AddTagsToCertificateError::InvalidArn(ref cause) => cause,
AddTagsToCertificateError::InvalidTag(ref cause) => cause,
AddTagsToCertificateError::ResourceNotFound(ref cause) => cause,
AddTagsToCertificateError::TooManyTags(ref cause) => cause,
AddTagsToCertificateError::Validation(ref cause) => cause,
AddTagsToCertificateError::Credentials(ref err) => err.description(),
AddTagsToCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AddTagsToCertificateError::ParseError(ref cause) => cause,
AddTagsToCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteCertificateError {
InvalidArn(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteCertificateError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidArnException" => {
return DeleteCertificateError::InvalidArn(String::from(error_message));
}
"ResourceInUseException" => {
return DeleteCertificateError::ResourceInUse(String::from(error_message));
}
"ResourceNotFoundException" => {
return DeleteCertificateError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DeleteCertificateError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteCertificateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteCertificateError {
fn from(err: serde_json::error::Error) -> DeleteCertificateError {
DeleteCertificateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteCertificateError {
fn from(err: CredentialsError) -> DeleteCertificateError {
DeleteCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteCertificateError {
fn from(err: HttpDispatchError) -> DeleteCertificateError {
DeleteCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteCertificateError {
fn from(err: io::Error) -> DeleteCertificateError {
DeleteCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteCertificateError {
fn description(&self) -> &str {
match *self {
DeleteCertificateError::InvalidArn(ref cause) => cause,
DeleteCertificateError::ResourceInUse(ref cause) => cause,
DeleteCertificateError::ResourceNotFound(ref cause) => cause,
DeleteCertificateError::Validation(ref cause) => cause,
DeleteCertificateError::Credentials(ref err) => err.description(),
DeleteCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteCertificateError::ParseError(ref cause) => cause,
DeleteCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeCertificateError {
InvalidArn(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeCertificateError {
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 {
"InvalidArnException" => {
return DescribeCertificateError::InvalidArn(String::from(error_message));
}
"ResourceNotFoundException" => {
return DescribeCertificateError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return DescribeCertificateError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeCertificateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeCertificateError {
fn from(err: serde_json::error::Error) -> DescribeCertificateError {
DescribeCertificateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeCertificateError {
fn from(err: CredentialsError) -> DescribeCertificateError {
DescribeCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeCertificateError {
fn from(err: HttpDispatchError) -> DescribeCertificateError {
DescribeCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeCertificateError {
fn from(err: io::Error) -> DescribeCertificateError {
DescribeCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeCertificateError {
fn description(&self) -> &str {
match *self {
DescribeCertificateError::InvalidArn(ref cause) => cause,
DescribeCertificateError::ResourceNotFound(ref cause) => cause,
DescribeCertificateError::Validation(ref cause) => cause,
DescribeCertificateError::Credentials(ref err) => err.description(),
DescribeCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeCertificateError::ParseError(ref cause) => cause,
DescribeCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ExportCertificateError {
InvalidArn(String),
RequestInProgress(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ExportCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> ExportCertificateError {
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 {
"InvalidArnException" => {
return ExportCertificateError::InvalidArn(String::from(error_message));
}
"RequestInProgressException" => {
return ExportCertificateError::RequestInProgress(String::from(error_message));
}
"ResourceNotFoundException" => {
return ExportCertificateError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return ExportCertificateError::Validation(error_message.to_string());
}
_ => {}
}
}
return ExportCertificateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ExportCertificateError {
fn from(err: serde_json::error::Error) -> ExportCertificateError {
ExportCertificateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ExportCertificateError {
fn from(err: CredentialsError) -> ExportCertificateError {
ExportCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for ExportCertificateError {
fn from(err: HttpDispatchError) -> ExportCertificateError {
ExportCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for ExportCertificateError {
fn from(err: io::Error) -> ExportCertificateError {
ExportCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ExportCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ExportCertificateError {
fn description(&self) -> &str {
match *self {
ExportCertificateError::InvalidArn(ref cause) => cause,
ExportCertificateError::RequestInProgress(ref cause) => cause,
ExportCertificateError::ResourceNotFound(ref cause) => cause,
ExportCertificateError::Validation(ref cause) => cause,
ExportCertificateError::Credentials(ref err) => err.description(),
ExportCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ExportCertificateError::ParseError(ref cause) => cause,
ExportCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetCertificateError {
InvalidArn(String),
RequestInProgress(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> GetCertificateError {
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 {
"InvalidArnException" => {
return GetCertificateError::InvalidArn(String::from(error_message));
}
"RequestInProgressException" => {
return GetCertificateError::RequestInProgress(String::from(error_message));
}
"ResourceNotFoundException" => {
return GetCertificateError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return GetCertificateError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetCertificateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetCertificateError {
fn from(err: serde_json::error::Error) -> GetCertificateError {
GetCertificateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetCertificateError {
fn from(err: CredentialsError) -> GetCertificateError {
GetCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetCertificateError {
fn from(err: HttpDispatchError) -> GetCertificateError {
GetCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for GetCertificateError {
fn from(err: io::Error) -> GetCertificateError {
GetCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetCertificateError {
fn description(&self) -> &str {
match *self {
GetCertificateError::InvalidArn(ref cause) => cause,
GetCertificateError::RequestInProgress(ref cause) => cause,
GetCertificateError::ResourceNotFound(ref cause) => cause,
GetCertificateError::Validation(ref cause) => cause,
GetCertificateError::Credentials(ref err) => err.description(),
GetCertificateError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetCertificateError::ParseError(ref cause) => cause,
GetCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ImportCertificateError {
LimitExceeded(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ImportCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> ImportCertificateError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"LimitExceededException" => {
return ImportCertificateError::LimitExceeded(String::from(error_message));
}
"ResourceNotFoundException" => {
return ImportCertificateError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return ImportCertificateError::Validation(error_message.to_string());
}
_ => {}
}
}
return ImportCertificateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ImportCertificateError {
fn from(err: serde_json::error::Error) -> ImportCertificateError {
ImportCertificateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ImportCertificateError {
fn from(err: CredentialsError) -> ImportCertificateError {
ImportCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for ImportCertificateError {
fn from(err: HttpDispatchError) -> ImportCertificateError {
ImportCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for ImportCertificateError {
fn from(err: io::Error) -> ImportCertificateError {
ImportCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ImportCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ImportCertificateError {
fn description(&self) -> &str {
match *self {
ImportCertificateError::LimitExceeded(ref cause) => cause,
ImportCertificateError::ResourceNotFound(ref cause) => cause,
ImportCertificateError::Validation(ref cause) => cause,
ImportCertificateError::Credentials(ref err) => err.description(),
ImportCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ImportCertificateError::ParseError(ref cause) => cause,
ImportCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListCertificatesError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListCertificatesError {
pub fn from_response(res: BufferedHttpResponse) -> ListCertificatesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ValidationException" => {
return ListCertificatesError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListCertificatesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListCertificatesError {
fn from(err: serde_json::error::Error) -> ListCertificatesError {
ListCertificatesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListCertificatesError {
fn from(err: CredentialsError) -> ListCertificatesError {
ListCertificatesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListCertificatesError {
fn from(err: HttpDispatchError) -> ListCertificatesError {
ListCertificatesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListCertificatesError {
fn from(err: io::Error) -> ListCertificatesError {
ListCertificatesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListCertificatesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListCertificatesError {
fn description(&self) -> &str {
match *self {
ListCertificatesError::Validation(ref cause) => cause,
ListCertificatesError::Credentials(ref err) => err.description(),
ListCertificatesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListCertificatesError::ParseError(ref cause) => cause,
ListCertificatesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTagsForCertificateError {
InvalidArn(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTagsForCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> ListTagsForCertificateError {
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 {
"InvalidArnException" => {
return ListTagsForCertificateError::InvalidArn(String::from(error_message));
}
"ResourceNotFoundException" => {
return ListTagsForCertificateError::ResourceNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return ListTagsForCertificateError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListTagsForCertificateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListTagsForCertificateError {
fn from(err: serde_json::error::Error) -> ListTagsForCertificateError {
ListTagsForCertificateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListTagsForCertificateError {
fn from(err: CredentialsError) -> ListTagsForCertificateError {
ListTagsForCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTagsForCertificateError {
fn from(err: HttpDispatchError) -> ListTagsForCertificateError {
ListTagsForCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTagsForCertificateError {
fn from(err: io::Error) -> ListTagsForCertificateError {
ListTagsForCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTagsForCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTagsForCertificateError {
fn description(&self) -> &str {
match *self {
ListTagsForCertificateError::InvalidArn(ref cause) => cause,
ListTagsForCertificateError::ResourceNotFound(ref cause) => cause,
ListTagsForCertificateError::Validation(ref cause) => cause,
ListTagsForCertificateError::Credentials(ref err) => err.description(),
ListTagsForCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTagsForCertificateError::ParseError(ref cause) => cause,
ListTagsForCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RemoveTagsFromCertificateError {
InvalidArn(String),
InvalidTag(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RemoveTagsFromCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> RemoveTagsFromCertificateError {
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 {
"InvalidArnException" => {
return RemoveTagsFromCertificateError::InvalidArn(String::from(error_message));
}
"InvalidTagException" => {
return RemoveTagsFromCertificateError::InvalidTag(String::from(error_message));
}
"ResourceNotFoundException" => {
return RemoveTagsFromCertificateError::ResourceNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return RemoveTagsFromCertificateError::Validation(error_message.to_string());
}
_ => {}
}
}
return RemoveTagsFromCertificateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RemoveTagsFromCertificateError {
fn from(err: serde_json::error::Error) -> RemoveTagsFromCertificateError {
RemoveTagsFromCertificateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RemoveTagsFromCertificateError {
fn from(err: CredentialsError) -> RemoveTagsFromCertificateError {
RemoveTagsFromCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for RemoveTagsFromCertificateError {
fn from(err: HttpDispatchError) -> RemoveTagsFromCertificateError {
RemoveTagsFromCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for RemoveTagsFromCertificateError {
fn from(err: io::Error) -> RemoveTagsFromCertificateError {
RemoveTagsFromCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RemoveTagsFromCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RemoveTagsFromCertificateError {
fn description(&self) -> &str {
match *self {
RemoveTagsFromCertificateError::InvalidArn(ref cause) => cause,
RemoveTagsFromCertificateError::InvalidTag(ref cause) => cause,
RemoveTagsFromCertificateError::ResourceNotFound(ref cause) => cause,
RemoveTagsFromCertificateError::Validation(ref cause) => cause,
RemoveTagsFromCertificateError::Credentials(ref err) => err.description(),
RemoveTagsFromCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RemoveTagsFromCertificateError::ParseError(ref cause) => cause,
RemoveTagsFromCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RequestCertificateError {
InvalidArn(String),
InvalidDomainValidationOptions(String),
LimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RequestCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> RequestCertificateError {
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 {
"InvalidArnException" => {
return RequestCertificateError::InvalidArn(String::from(error_message));
}
"InvalidDomainValidationOptionsException" => {
return RequestCertificateError::InvalidDomainValidationOptions(String::from(
error_message,
));
}
"LimitExceededException" => {
return RequestCertificateError::LimitExceeded(String::from(error_message));
}
"ValidationException" => {
return RequestCertificateError::Validation(error_message.to_string());
}
_ => {}
}
}
return RequestCertificateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RequestCertificateError {
fn from(err: serde_json::error::Error) -> RequestCertificateError {
RequestCertificateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RequestCertificateError {
fn from(err: CredentialsError) -> RequestCertificateError {
RequestCertificateError::Credentials(err)
}
}
impl From<HttpDispatchError> for RequestCertificateError {
fn from(err: HttpDispatchError) -> RequestCertificateError {
RequestCertificateError::HttpDispatch(err)
}
}
impl From<io::Error> for RequestCertificateError {
fn from(err: io::Error) -> RequestCertificateError {
RequestCertificateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RequestCertificateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RequestCertificateError {
fn description(&self) -> &str {
match *self {
RequestCertificateError::InvalidArn(ref cause) => cause,
RequestCertificateError::InvalidDomainValidationOptions(ref cause) => cause,
RequestCertificateError::LimitExceeded(ref cause) => cause,
RequestCertificateError::Validation(ref cause) => cause,
RequestCertificateError::Credentials(ref err) => err.description(),
RequestCertificateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RequestCertificateError::ParseError(ref cause) => cause,
RequestCertificateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ResendValidationEmailError {
InvalidArn(String),
InvalidDomainValidationOptions(String),
InvalidState(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ResendValidationEmailError {
pub fn from_response(res: BufferedHttpResponse) -> ResendValidationEmailError {
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 {
"InvalidArnException" => {
return ResendValidationEmailError::InvalidArn(String::from(error_message));
}
"InvalidDomainValidationOptionsException" => {
return ResendValidationEmailError::InvalidDomainValidationOptions(String::from(
error_message,
));
}
"InvalidStateException" => {
return ResendValidationEmailError::InvalidState(String::from(error_message));
}
"ResourceNotFoundException" => {
return ResendValidationEmailError::ResourceNotFound(String::from(error_message));
}
"ValidationException" => {
return ResendValidationEmailError::Validation(error_message.to_string());
}
_ => {}
}
}
return ResendValidationEmailError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ResendValidationEmailError {
fn from(err: serde_json::error::Error) -> ResendValidationEmailError {
ResendValidationEmailError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ResendValidationEmailError {
fn from(err: CredentialsError) -> ResendValidationEmailError {
ResendValidationEmailError::Credentials(err)
}
}
impl From<HttpDispatchError> for ResendValidationEmailError {
fn from(err: HttpDispatchError) -> ResendValidationEmailError {
ResendValidationEmailError::HttpDispatch(err)
}
}
impl From<io::Error> for ResendValidationEmailError {
fn from(err: io::Error) -> ResendValidationEmailError {
ResendValidationEmailError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ResendValidationEmailError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResendValidationEmailError {
fn description(&self) -> &str {
match *self {
ResendValidationEmailError::InvalidArn(ref cause) => cause,
ResendValidationEmailError::InvalidDomainValidationOptions(ref cause) => cause,
ResendValidationEmailError::InvalidState(ref cause) => cause,
ResendValidationEmailError::ResourceNotFound(ref cause) => cause,
ResendValidationEmailError::Validation(ref cause) => cause,
ResendValidationEmailError::Credentials(ref err) => err.description(),
ResendValidationEmailError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ResendValidationEmailError::ParseError(ref cause) => cause,
ResendValidationEmailError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateCertificateOptionsError {
InvalidArn(String),
InvalidState(String),
LimitExceeded(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateCertificateOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateCertificateOptionsError {
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 {
"InvalidArnException" => {
return UpdateCertificateOptionsError::InvalidArn(String::from(error_message));
}
"InvalidStateException" => {
return UpdateCertificateOptionsError::InvalidState(String::from(error_message));
}
"LimitExceededException" => {
return UpdateCertificateOptionsError::LimitExceeded(String::from(error_message));
}
"ResourceNotFoundException" => {
return UpdateCertificateOptionsError::ResourceNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return UpdateCertificateOptionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateCertificateOptionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateCertificateOptionsError {
fn from(err: serde_json::error::Error) -> UpdateCertificateOptionsError {
UpdateCertificateOptionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateCertificateOptionsError {
fn from(err: CredentialsError) -> UpdateCertificateOptionsError {
UpdateCertificateOptionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateCertificateOptionsError {
fn from(err: HttpDispatchError) -> UpdateCertificateOptionsError {
UpdateCertificateOptionsError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateCertificateOptionsError {
fn from(err: io::Error) -> UpdateCertificateOptionsError {
UpdateCertificateOptionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateCertificateOptionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateCertificateOptionsError {
fn description(&self) -> &str {
match *self {
UpdateCertificateOptionsError::InvalidArn(ref cause) => cause,
UpdateCertificateOptionsError::InvalidState(ref cause) => cause,
UpdateCertificateOptionsError::LimitExceeded(ref cause) => cause,
UpdateCertificateOptionsError::ResourceNotFound(ref cause) => cause,
UpdateCertificateOptionsError::Validation(ref cause) => cause,
UpdateCertificateOptionsError::Credentials(ref err) => err.description(),
UpdateCertificateOptionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateCertificateOptionsError::ParseError(ref cause) => cause,
UpdateCertificateOptionsError::Unknown(_) => "unknown error",
}
}
}
pub trait Acm {
fn add_tags_to_certificate(
&self,
input: AddTagsToCertificateRequest,
) -> RusotoFuture<(), AddTagsToCertificateError>;
fn delete_certificate(
&self,
input: DeleteCertificateRequest,
) -> RusotoFuture<(), DeleteCertificateError>;
fn describe_certificate(
&self,
input: DescribeCertificateRequest,
) -> RusotoFuture<DescribeCertificateResponse, DescribeCertificateError>;
fn export_certificate(
&self,
input: ExportCertificateRequest,
) -> RusotoFuture<ExportCertificateResponse, ExportCertificateError>;
fn get_certificate(
&self,
input: GetCertificateRequest,
) -> RusotoFuture<GetCertificateResponse, GetCertificateError>;
fn import_certificate(
&self,
input: ImportCertificateRequest,
) -> RusotoFuture<ImportCertificateResponse, ImportCertificateError>;
fn list_certificates(
&self,
input: ListCertificatesRequest,
) -> RusotoFuture<ListCertificatesResponse, ListCertificatesError>;
fn list_tags_for_certificate(
&self,
input: ListTagsForCertificateRequest,
) -> RusotoFuture<ListTagsForCertificateResponse, ListTagsForCertificateError>;
fn remove_tags_from_certificate(
&self,
input: RemoveTagsFromCertificateRequest,
) -> RusotoFuture<(), RemoveTagsFromCertificateError>;
fn request_certificate(
&self,
input: RequestCertificateRequest,
) -> RusotoFuture<RequestCertificateResponse, RequestCertificateError>;
fn resend_validation_email(
&self,
input: ResendValidationEmailRequest,
) -> RusotoFuture<(), ResendValidationEmailError>;
fn update_certificate_options(
&self,
input: UpdateCertificateOptionsRequest,
) -> RusotoFuture<(), UpdateCertificateOptionsError>;
}
#[derive(Clone)]
pub struct AcmClient {
client: Client,
region: region::Region,
}
impl AcmClient {
pub fn new(region: region::Region) -> AcmClient {
AcmClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> AcmClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
AcmClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl Acm for AcmClient {
fn add_tags_to_certificate(
&self,
input: AddTagsToCertificateRequest,
) -> RusotoFuture<(), AddTagsToCertificateError> {
let mut request = SignedRequest::new("POST", "acm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CertificateManager.AddTagsToCertificate");
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(AddTagsToCertificateError::from_response(response))
}),
)
}
})
}
fn delete_certificate(
&self,
input: DeleteCertificateRequest,
) -> RusotoFuture<(), DeleteCertificateError> {
let mut request = SignedRequest::new("POST", "acm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CertificateManager.DeleteCertificate");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteCertificateError::from_response(response))),
)
}
})
}
fn describe_certificate(
&self,
input: DescribeCertificateRequest,
) -> RusotoFuture<DescribeCertificateResponse, DescribeCertificateError> {
let mut request = SignedRequest::new("POST", "acm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CertificateManager.DescribeCertificate");
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::<DescribeCertificateResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeCertificateError::from_response(response))
}),
)
}
})
}
fn export_certificate(
&self,
input: ExportCertificateRequest,
) -> RusotoFuture<ExportCertificateResponse, ExportCertificateError> {
let mut request = SignedRequest::new("POST", "acm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CertificateManager.ExportCertificate");
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::<ExportCertificateResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ExportCertificateError::from_response(response))),
)
}
})
}
fn get_certificate(
&self,
input: GetCertificateRequest,
) -> RusotoFuture<GetCertificateResponse, GetCertificateError> {
let mut request = SignedRequest::new("POST", "acm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CertificateManager.GetCertificate");
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::<GetCertificateResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetCertificateError::from_response(response))),
)
}
})
}
fn import_certificate(
&self,
input: ImportCertificateRequest,
) -> RusotoFuture<ImportCertificateResponse, ImportCertificateError> {
let mut request = SignedRequest::new("POST", "acm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CertificateManager.ImportCertificate");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ImportCertificateResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ImportCertificateError::from_response(response))),
)
}
})
}
fn list_certificates(
&self,
input: ListCertificatesRequest,
) -> RusotoFuture<ListCertificatesResponse, ListCertificatesError> {
let mut request = SignedRequest::new("POST", "acm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CertificateManager.ListCertificates");
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::<ListCertificatesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListCertificatesError::from_response(response))),
)
}
})
}
fn list_tags_for_certificate(
&self,
input: ListTagsForCertificateRequest,
) -> RusotoFuture<ListTagsForCertificateResponse, ListTagsForCertificateError> {
let mut request = SignedRequest::new("POST", "acm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CertificateManager.ListTagsForCertificate");
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::<ListTagsForCertificateResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListTagsForCertificateError::from_response(response))
}),
)
}
})
}
fn remove_tags_from_certificate(
&self,
input: RemoveTagsFromCertificateRequest,
) -> RusotoFuture<(), RemoveTagsFromCertificateError> {
let mut request = SignedRequest::new("POST", "acm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"CertificateManager.RemoveTagsFromCertificate",
);
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(RemoveTagsFromCertificateError::from_response(response))
}))
}
})
}
fn request_certificate(
&self,
input: RequestCertificateRequest,
) -> RusotoFuture<RequestCertificateResponse, RequestCertificateError> {
let mut request = SignedRequest::new("POST", "acm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CertificateManager.RequestCertificate");
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::<RequestCertificateResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RequestCertificateError::from_response(response))),
)
}
})
}
fn resend_validation_email(
&self,
input: ResendValidationEmailRequest,
) -> RusotoFuture<(), ResendValidationEmailError> {
let mut request = SignedRequest::new("POST", "acm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CertificateManager.ResendValidationEmail");
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(ResendValidationEmailError::from_response(response))
}),
)
}
})
}
fn update_certificate_options(
&self,
input: UpdateCertificateOptionsRequest,
) -> RusotoFuture<(), UpdateCertificateOptionsError> {
let mut request = SignedRequest::new("POST", "acm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"CertificateManager.UpdateCertificateOptions",
);
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(UpdateCertificateOptionsError::from_response(response))
}))
}
})
}
}
#[cfg(test)]
mod protocol_tests {}