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 AssociateCreatedArtifactRequest {
#[serde(rename = "CreatedArtifact")]
pub created_artifact: CreatedArtifact,
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "MigrationTaskName")]
pub migration_task_name: String,
#[serde(rename = "ProgressUpdateStream")]
pub progress_update_stream: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssociateCreatedArtifactResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AssociateDiscoveredResourceRequest {
#[serde(rename = "DiscoveredResource")]
pub discovered_resource: DiscoveredResource,
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "MigrationTaskName")]
pub migration_task_name: String,
#[serde(rename = "ProgressUpdateStream")]
pub progress_update_stream: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssociateDiscoveredResourceResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateProgressUpdateStreamRequest {
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "ProgressUpdateStreamName")]
pub progress_update_stream_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateProgressUpdateStreamResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreatedArtifact {
#[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, Serialize)]
pub struct DeleteProgressUpdateStreamRequest {
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "ProgressUpdateStreamName")]
pub progress_update_stream_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteProgressUpdateStreamResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeApplicationStateRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeApplicationStateResult {
#[serde(rename = "ApplicationStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_status: Option<String>,
#[serde(rename = "LastUpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeMigrationTaskRequest {
#[serde(rename = "MigrationTaskName")]
pub migration_task_name: String,
#[serde(rename = "ProgressUpdateStream")]
pub progress_update_stream: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeMigrationTaskResult {
#[serde(rename = "MigrationTask")]
#[serde(skip_serializing_if = "Option::is_none")]
pub migration_task: Option<MigrationTask>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DisassociateCreatedArtifactRequest {
#[serde(rename = "CreatedArtifactName")]
pub created_artifact_name: String,
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "MigrationTaskName")]
pub migration_task_name: String,
#[serde(rename = "ProgressUpdateStream")]
pub progress_update_stream: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DisassociateCreatedArtifactResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DisassociateDiscoveredResourceRequest {
#[serde(rename = "ConfigurationId")]
pub configuration_id: String,
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "MigrationTaskName")]
pub migration_task_name: String,
#[serde(rename = "ProgressUpdateStream")]
pub progress_update_stream: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DisassociateDiscoveredResourceResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DiscoveredResource {
#[serde(rename = "ConfigurationId")]
pub configuration_id: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ImportMigrationTaskRequest {
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "MigrationTaskName")]
pub migration_task_name: String,
#[serde(rename = "ProgressUpdateStream")]
pub progress_update_stream: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ImportMigrationTaskResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListCreatedArtifactsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "MigrationTaskName")]
pub migration_task_name: String,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ProgressUpdateStream")]
pub progress_update_stream: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListCreatedArtifactsResult {
#[serde(rename = "CreatedArtifactList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_artifact_list: Option<Vec<CreatedArtifact>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListDiscoveredResourcesRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "MigrationTaskName")]
pub migration_task_name: String,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ProgressUpdateStream")]
pub progress_update_stream: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListDiscoveredResourcesResult {
#[serde(rename = "DiscoveredResourceList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub discovered_resource_list: Option<Vec<DiscoveredResource>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListMigrationTasksRequest {
#[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 = "ResourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListMigrationTasksResult {
#[serde(rename = "MigrationTaskSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub migration_task_summary_list: Option<Vec<MigrationTaskSummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListProgressUpdateStreamsRequest {
#[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 ListProgressUpdateStreamsResult {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ProgressUpdateStreamSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub progress_update_stream_summary_list: Option<Vec<ProgressUpdateStreamSummary>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct MigrationTask {
#[serde(rename = "MigrationTaskName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub migration_task_name: Option<String>,
#[serde(rename = "ProgressUpdateStream")]
#[serde(skip_serializing_if = "Option::is_none")]
pub progress_update_stream: Option<String>,
#[serde(rename = "ResourceAttributeList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_attribute_list: Option<Vec<ResourceAttribute>>,
#[serde(rename = "Task")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task: Option<Task>,
#[serde(rename = "UpdateDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_date_time: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct MigrationTaskSummary {
#[serde(rename = "MigrationTaskName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub migration_task_name: Option<String>,
#[serde(rename = "ProgressPercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub progress_percent: Option<i64>,
#[serde(rename = "ProgressUpdateStream")]
#[serde(skip_serializing_if = "Option::is_none")]
pub progress_update_stream: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_detail: Option<String>,
#[serde(rename = "UpdateDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_date_time: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct NotifyApplicationStateRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct NotifyApplicationStateResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct NotifyMigrationTaskStateRequest {
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "MigrationTaskName")]
pub migration_task_name: String,
#[serde(rename = "NextUpdateSeconds")]
pub next_update_seconds: i64,
#[serde(rename = "ProgressUpdateStream")]
pub progress_update_stream: String,
#[serde(rename = "Task")]
pub task: Task,
#[serde(rename = "UpdateDateTime")]
pub update_date_time: f64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct NotifyMigrationTaskStateResult {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ProgressUpdateStreamSummary {
#[serde(rename = "ProgressUpdateStreamName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub progress_update_stream_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct PutResourceAttributesRequest {
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "MigrationTaskName")]
pub migration_task_name: String,
#[serde(rename = "ProgressUpdateStream")]
pub progress_update_stream: String,
#[serde(rename = "ResourceAttributeList")]
pub resource_attribute_list: Vec<ResourceAttribute>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct PutResourceAttributesResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ResourceAttribute {
#[serde(rename = "Type")]
pub type_: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Task {
#[serde(rename = "ProgressPercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub progress_percent: Option<i64>,
#[serde(rename = "Status")]
pub status: String,
#[serde(rename = "StatusDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_detail: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AssociateCreatedArtifactError {
AccessDenied(String),
DryRunOperation(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AssociateCreatedArtifactError {
pub fn from_response(res: BufferedHttpResponse) -> AssociateCreatedArtifactError {
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 {
"AccessDeniedException" => {
return AssociateCreatedArtifactError::AccessDenied(String::from(error_message));
}
"DryRunOperation" => {
return AssociateCreatedArtifactError::DryRunOperation(String::from(
error_message,
));
}
"InternalServerError" => {
return AssociateCreatedArtifactError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return AssociateCreatedArtifactError::InvalidInput(String::from(error_message));
}
"ResourceNotFoundException" => {
return AssociateCreatedArtifactError::ResourceNotFound(String::from(
error_message,
));
}
"ServiceUnavailableException" => {
return AssociateCreatedArtifactError::ServiceUnavailable(String::from(
error_message,
));
}
"UnauthorizedOperation" => {
return AssociateCreatedArtifactError::UnauthorizedOperation(String::from(
error_message,
));
}
"ValidationException" => {
return AssociateCreatedArtifactError::Validation(error_message.to_string());
}
_ => {}
}
}
return AssociateCreatedArtifactError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AssociateCreatedArtifactError {
fn from(err: serde_json::error::Error) -> AssociateCreatedArtifactError {
AssociateCreatedArtifactError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AssociateCreatedArtifactError {
fn from(err: CredentialsError) -> AssociateCreatedArtifactError {
AssociateCreatedArtifactError::Credentials(err)
}
}
impl From<HttpDispatchError> for AssociateCreatedArtifactError {
fn from(err: HttpDispatchError) -> AssociateCreatedArtifactError {
AssociateCreatedArtifactError::HttpDispatch(err)
}
}
impl From<io::Error> for AssociateCreatedArtifactError {
fn from(err: io::Error) -> AssociateCreatedArtifactError {
AssociateCreatedArtifactError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AssociateCreatedArtifactError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateCreatedArtifactError {
fn description(&self) -> &str {
match *self {
AssociateCreatedArtifactError::AccessDenied(ref cause) => cause,
AssociateCreatedArtifactError::DryRunOperation(ref cause) => cause,
AssociateCreatedArtifactError::InternalServerError(ref cause) => cause,
AssociateCreatedArtifactError::InvalidInput(ref cause) => cause,
AssociateCreatedArtifactError::ResourceNotFound(ref cause) => cause,
AssociateCreatedArtifactError::ServiceUnavailable(ref cause) => cause,
AssociateCreatedArtifactError::UnauthorizedOperation(ref cause) => cause,
AssociateCreatedArtifactError::Validation(ref cause) => cause,
AssociateCreatedArtifactError::Credentials(ref err) => err.description(),
AssociateCreatedArtifactError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AssociateCreatedArtifactError::ParseError(ref cause) => cause,
AssociateCreatedArtifactError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AssociateDiscoveredResourceError {
AccessDenied(String),
DryRunOperation(String),
InternalServerError(String),
InvalidInput(String),
PolicyError(String),
ResourceNotFound(String),
ServiceUnavailable(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AssociateDiscoveredResourceError {
pub fn from_response(res: BufferedHttpResponse) -> AssociateDiscoveredResourceError {
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 {
"AccessDeniedException" => {
return AssociateDiscoveredResourceError::AccessDenied(String::from(
error_message,
));
}
"DryRunOperation" => {
return AssociateDiscoveredResourceError::DryRunOperation(String::from(
error_message,
));
}
"InternalServerError" => {
return AssociateDiscoveredResourceError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return AssociateDiscoveredResourceError::InvalidInput(String::from(
error_message,
));
}
"PolicyErrorException" => {
return AssociateDiscoveredResourceError::PolicyError(String::from(
error_message,
));
}
"ResourceNotFoundException" => {
return AssociateDiscoveredResourceError::ResourceNotFound(String::from(
error_message,
));
}
"ServiceUnavailableException" => {
return AssociateDiscoveredResourceError::ServiceUnavailable(String::from(
error_message,
));
}
"UnauthorizedOperation" => {
return AssociateDiscoveredResourceError::UnauthorizedOperation(String::from(
error_message,
));
}
"ValidationException" => {
return AssociateDiscoveredResourceError::Validation(error_message.to_string());
}
_ => {}
}
}
return AssociateDiscoveredResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AssociateDiscoveredResourceError {
fn from(err: serde_json::error::Error) -> AssociateDiscoveredResourceError {
AssociateDiscoveredResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AssociateDiscoveredResourceError {
fn from(err: CredentialsError) -> AssociateDiscoveredResourceError {
AssociateDiscoveredResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for AssociateDiscoveredResourceError {
fn from(err: HttpDispatchError) -> AssociateDiscoveredResourceError {
AssociateDiscoveredResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for AssociateDiscoveredResourceError {
fn from(err: io::Error) -> AssociateDiscoveredResourceError {
AssociateDiscoveredResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AssociateDiscoveredResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateDiscoveredResourceError {
fn description(&self) -> &str {
match *self {
AssociateDiscoveredResourceError::AccessDenied(ref cause) => cause,
AssociateDiscoveredResourceError::DryRunOperation(ref cause) => cause,
AssociateDiscoveredResourceError::InternalServerError(ref cause) => cause,
AssociateDiscoveredResourceError::InvalidInput(ref cause) => cause,
AssociateDiscoveredResourceError::PolicyError(ref cause) => cause,
AssociateDiscoveredResourceError::ResourceNotFound(ref cause) => cause,
AssociateDiscoveredResourceError::ServiceUnavailable(ref cause) => cause,
AssociateDiscoveredResourceError::UnauthorizedOperation(ref cause) => cause,
AssociateDiscoveredResourceError::Validation(ref cause) => cause,
AssociateDiscoveredResourceError::Credentials(ref err) => err.description(),
AssociateDiscoveredResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AssociateDiscoveredResourceError::ParseError(ref cause) => cause,
AssociateDiscoveredResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateProgressUpdateStreamError {
AccessDenied(String),
DryRunOperation(String),
InternalServerError(String),
InvalidInput(String),
ServiceUnavailable(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateProgressUpdateStreamError {
pub fn from_response(res: BufferedHttpResponse) -> CreateProgressUpdateStreamError {
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 {
"AccessDeniedException" => {
return CreateProgressUpdateStreamError::AccessDenied(String::from(
error_message,
));
}
"DryRunOperation" => {
return CreateProgressUpdateStreamError::DryRunOperation(String::from(
error_message,
));
}
"InternalServerError" => {
return CreateProgressUpdateStreamError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return CreateProgressUpdateStreamError::InvalidInput(String::from(
error_message,
));
}
"ServiceUnavailableException" => {
return CreateProgressUpdateStreamError::ServiceUnavailable(String::from(
error_message,
));
}
"UnauthorizedOperation" => {
return CreateProgressUpdateStreamError::UnauthorizedOperation(String::from(
error_message,
));
}
"ValidationException" => {
return CreateProgressUpdateStreamError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateProgressUpdateStreamError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateProgressUpdateStreamError {
fn from(err: serde_json::error::Error) -> CreateProgressUpdateStreamError {
CreateProgressUpdateStreamError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateProgressUpdateStreamError {
fn from(err: CredentialsError) -> CreateProgressUpdateStreamError {
CreateProgressUpdateStreamError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateProgressUpdateStreamError {
fn from(err: HttpDispatchError) -> CreateProgressUpdateStreamError {
CreateProgressUpdateStreamError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateProgressUpdateStreamError {
fn from(err: io::Error) -> CreateProgressUpdateStreamError {
CreateProgressUpdateStreamError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateProgressUpdateStreamError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateProgressUpdateStreamError {
fn description(&self) -> &str {
match *self {
CreateProgressUpdateStreamError::AccessDenied(ref cause) => cause,
CreateProgressUpdateStreamError::DryRunOperation(ref cause) => cause,
CreateProgressUpdateStreamError::InternalServerError(ref cause) => cause,
CreateProgressUpdateStreamError::InvalidInput(ref cause) => cause,
CreateProgressUpdateStreamError::ServiceUnavailable(ref cause) => cause,
CreateProgressUpdateStreamError::UnauthorizedOperation(ref cause) => cause,
CreateProgressUpdateStreamError::Validation(ref cause) => cause,
CreateProgressUpdateStreamError::Credentials(ref err) => err.description(),
CreateProgressUpdateStreamError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateProgressUpdateStreamError::ParseError(ref cause) => cause,
CreateProgressUpdateStreamError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteProgressUpdateStreamError {
AccessDenied(String),
DryRunOperation(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteProgressUpdateStreamError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteProgressUpdateStreamError {
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 {
"AccessDeniedException" => {
return DeleteProgressUpdateStreamError::AccessDenied(String::from(
error_message,
));
}
"DryRunOperation" => {
return DeleteProgressUpdateStreamError::DryRunOperation(String::from(
error_message,
));
}
"InternalServerError" => {
return DeleteProgressUpdateStreamError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return DeleteProgressUpdateStreamError::InvalidInput(String::from(
error_message,
));
}
"ResourceNotFoundException" => {
return DeleteProgressUpdateStreamError::ResourceNotFound(String::from(
error_message,
));
}
"ServiceUnavailableException" => {
return DeleteProgressUpdateStreamError::ServiceUnavailable(String::from(
error_message,
));
}
"UnauthorizedOperation" => {
return DeleteProgressUpdateStreamError::UnauthorizedOperation(String::from(
error_message,
));
}
"ValidationException" => {
return DeleteProgressUpdateStreamError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteProgressUpdateStreamError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteProgressUpdateStreamError {
fn from(err: serde_json::error::Error) -> DeleteProgressUpdateStreamError {
DeleteProgressUpdateStreamError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteProgressUpdateStreamError {
fn from(err: CredentialsError) -> DeleteProgressUpdateStreamError {
DeleteProgressUpdateStreamError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteProgressUpdateStreamError {
fn from(err: HttpDispatchError) -> DeleteProgressUpdateStreamError {
DeleteProgressUpdateStreamError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteProgressUpdateStreamError {
fn from(err: io::Error) -> DeleteProgressUpdateStreamError {
DeleteProgressUpdateStreamError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteProgressUpdateStreamError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteProgressUpdateStreamError {
fn description(&self) -> &str {
match *self {
DeleteProgressUpdateStreamError::AccessDenied(ref cause) => cause,
DeleteProgressUpdateStreamError::DryRunOperation(ref cause) => cause,
DeleteProgressUpdateStreamError::InternalServerError(ref cause) => cause,
DeleteProgressUpdateStreamError::InvalidInput(ref cause) => cause,
DeleteProgressUpdateStreamError::ResourceNotFound(ref cause) => cause,
DeleteProgressUpdateStreamError::ServiceUnavailable(ref cause) => cause,
DeleteProgressUpdateStreamError::UnauthorizedOperation(ref cause) => cause,
DeleteProgressUpdateStreamError::Validation(ref cause) => cause,
DeleteProgressUpdateStreamError::Credentials(ref err) => err.description(),
DeleteProgressUpdateStreamError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteProgressUpdateStreamError::ParseError(ref cause) => cause,
DeleteProgressUpdateStreamError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeApplicationStateError {
AccessDenied(String),
InternalServerError(String),
InvalidInput(String),
PolicyError(String),
ResourceNotFound(String),
ServiceUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeApplicationStateError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeApplicationStateError {
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 {
"AccessDeniedException" => {
return DescribeApplicationStateError::AccessDenied(String::from(error_message));
}
"InternalServerError" => {
return DescribeApplicationStateError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return DescribeApplicationStateError::InvalidInput(String::from(error_message));
}
"PolicyErrorException" => {
return DescribeApplicationStateError::PolicyError(String::from(error_message));
}
"ResourceNotFoundException" => {
return DescribeApplicationStateError::ResourceNotFound(String::from(
error_message,
));
}
"ServiceUnavailableException" => {
return DescribeApplicationStateError::ServiceUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return DescribeApplicationStateError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeApplicationStateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeApplicationStateError {
fn from(err: serde_json::error::Error) -> DescribeApplicationStateError {
DescribeApplicationStateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeApplicationStateError {
fn from(err: CredentialsError) -> DescribeApplicationStateError {
DescribeApplicationStateError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeApplicationStateError {
fn from(err: HttpDispatchError) -> DescribeApplicationStateError {
DescribeApplicationStateError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeApplicationStateError {
fn from(err: io::Error) -> DescribeApplicationStateError {
DescribeApplicationStateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeApplicationStateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeApplicationStateError {
fn description(&self) -> &str {
match *self {
DescribeApplicationStateError::AccessDenied(ref cause) => cause,
DescribeApplicationStateError::InternalServerError(ref cause) => cause,
DescribeApplicationStateError::InvalidInput(ref cause) => cause,
DescribeApplicationStateError::PolicyError(ref cause) => cause,
DescribeApplicationStateError::ResourceNotFound(ref cause) => cause,
DescribeApplicationStateError::ServiceUnavailable(ref cause) => cause,
DescribeApplicationStateError::Validation(ref cause) => cause,
DescribeApplicationStateError::Credentials(ref err) => err.description(),
DescribeApplicationStateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeApplicationStateError::ParseError(ref cause) => cause,
DescribeApplicationStateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeMigrationTaskError {
AccessDenied(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeMigrationTaskError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeMigrationTaskError {
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 {
"AccessDeniedException" => {
return DescribeMigrationTaskError::AccessDenied(String::from(error_message));
}
"InternalServerError" => {
return DescribeMigrationTaskError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return DescribeMigrationTaskError::InvalidInput(String::from(error_message));
}
"ResourceNotFoundException" => {
return DescribeMigrationTaskError::ResourceNotFound(String::from(error_message));
}
"ServiceUnavailableException" => {
return DescribeMigrationTaskError::ServiceUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return DescribeMigrationTaskError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeMigrationTaskError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeMigrationTaskError {
fn from(err: serde_json::error::Error) -> DescribeMigrationTaskError {
DescribeMigrationTaskError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeMigrationTaskError {
fn from(err: CredentialsError) -> DescribeMigrationTaskError {
DescribeMigrationTaskError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeMigrationTaskError {
fn from(err: HttpDispatchError) -> DescribeMigrationTaskError {
DescribeMigrationTaskError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeMigrationTaskError {
fn from(err: io::Error) -> DescribeMigrationTaskError {
DescribeMigrationTaskError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeMigrationTaskError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeMigrationTaskError {
fn description(&self) -> &str {
match *self {
DescribeMigrationTaskError::AccessDenied(ref cause) => cause,
DescribeMigrationTaskError::InternalServerError(ref cause) => cause,
DescribeMigrationTaskError::InvalidInput(ref cause) => cause,
DescribeMigrationTaskError::ResourceNotFound(ref cause) => cause,
DescribeMigrationTaskError::ServiceUnavailable(ref cause) => cause,
DescribeMigrationTaskError::Validation(ref cause) => cause,
DescribeMigrationTaskError::Credentials(ref err) => err.description(),
DescribeMigrationTaskError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeMigrationTaskError::ParseError(ref cause) => cause,
DescribeMigrationTaskError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateCreatedArtifactError {
AccessDenied(String),
DryRunOperation(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisassociateCreatedArtifactError {
pub fn from_response(res: BufferedHttpResponse) -> DisassociateCreatedArtifactError {
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 {
"AccessDeniedException" => {
return DisassociateCreatedArtifactError::AccessDenied(String::from(
error_message,
));
}
"DryRunOperation" => {
return DisassociateCreatedArtifactError::DryRunOperation(String::from(
error_message,
));
}
"InternalServerError" => {
return DisassociateCreatedArtifactError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return DisassociateCreatedArtifactError::InvalidInput(String::from(
error_message,
));
}
"ResourceNotFoundException" => {
return DisassociateCreatedArtifactError::ResourceNotFound(String::from(
error_message,
));
}
"ServiceUnavailableException" => {
return DisassociateCreatedArtifactError::ServiceUnavailable(String::from(
error_message,
));
}
"UnauthorizedOperation" => {
return DisassociateCreatedArtifactError::UnauthorizedOperation(String::from(
error_message,
));
}
"ValidationException" => {
return DisassociateCreatedArtifactError::Validation(error_message.to_string());
}
_ => {}
}
}
return DisassociateCreatedArtifactError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DisassociateCreatedArtifactError {
fn from(err: serde_json::error::Error) -> DisassociateCreatedArtifactError {
DisassociateCreatedArtifactError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DisassociateCreatedArtifactError {
fn from(err: CredentialsError) -> DisassociateCreatedArtifactError {
DisassociateCreatedArtifactError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisassociateCreatedArtifactError {
fn from(err: HttpDispatchError) -> DisassociateCreatedArtifactError {
DisassociateCreatedArtifactError::HttpDispatch(err)
}
}
impl From<io::Error> for DisassociateCreatedArtifactError {
fn from(err: io::Error) -> DisassociateCreatedArtifactError {
DisassociateCreatedArtifactError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisassociateCreatedArtifactError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateCreatedArtifactError {
fn description(&self) -> &str {
match *self {
DisassociateCreatedArtifactError::AccessDenied(ref cause) => cause,
DisassociateCreatedArtifactError::DryRunOperation(ref cause) => cause,
DisassociateCreatedArtifactError::InternalServerError(ref cause) => cause,
DisassociateCreatedArtifactError::InvalidInput(ref cause) => cause,
DisassociateCreatedArtifactError::ResourceNotFound(ref cause) => cause,
DisassociateCreatedArtifactError::ServiceUnavailable(ref cause) => cause,
DisassociateCreatedArtifactError::UnauthorizedOperation(ref cause) => cause,
DisassociateCreatedArtifactError::Validation(ref cause) => cause,
DisassociateCreatedArtifactError::Credentials(ref err) => err.description(),
DisassociateCreatedArtifactError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DisassociateCreatedArtifactError::ParseError(ref cause) => cause,
DisassociateCreatedArtifactError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateDiscoveredResourceError {
AccessDenied(String),
DryRunOperation(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisassociateDiscoveredResourceError {
pub fn from_response(res: BufferedHttpResponse) -> DisassociateDiscoveredResourceError {
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 {
"AccessDeniedException" => {
return DisassociateDiscoveredResourceError::AccessDenied(String::from(
error_message,
));
}
"DryRunOperation" => {
return DisassociateDiscoveredResourceError::DryRunOperation(String::from(
error_message,
));
}
"InternalServerError" => {
return DisassociateDiscoveredResourceError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return DisassociateDiscoveredResourceError::InvalidInput(String::from(
error_message,
));
}
"ResourceNotFoundException" => {
return DisassociateDiscoveredResourceError::ResourceNotFound(String::from(
error_message,
));
}
"ServiceUnavailableException" => {
return DisassociateDiscoveredResourceError::ServiceUnavailable(String::from(
error_message,
));
}
"UnauthorizedOperation" => {
return DisassociateDiscoveredResourceError::UnauthorizedOperation(String::from(
error_message,
));
}
"ValidationException" => {
return DisassociateDiscoveredResourceError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return DisassociateDiscoveredResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DisassociateDiscoveredResourceError {
fn from(err: serde_json::error::Error) -> DisassociateDiscoveredResourceError {
DisassociateDiscoveredResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DisassociateDiscoveredResourceError {
fn from(err: CredentialsError) -> DisassociateDiscoveredResourceError {
DisassociateDiscoveredResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisassociateDiscoveredResourceError {
fn from(err: HttpDispatchError) -> DisassociateDiscoveredResourceError {
DisassociateDiscoveredResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for DisassociateDiscoveredResourceError {
fn from(err: io::Error) -> DisassociateDiscoveredResourceError {
DisassociateDiscoveredResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisassociateDiscoveredResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateDiscoveredResourceError {
fn description(&self) -> &str {
match *self {
DisassociateDiscoveredResourceError::AccessDenied(ref cause) => cause,
DisassociateDiscoveredResourceError::DryRunOperation(ref cause) => cause,
DisassociateDiscoveredResourceError::InternalServerError(ref cause) => cause,
DisassociateDiscoveredResourceError::InvalidInput(ref cause) => cause,
DisassociateDiscoveredResourceError::ResourceNotFound(ref cause) => cause,
DisassociateDiscoveredResourceError::ServiceUnavailable(ref cause) => cause,
DisassociateDiscoveredResourceError::UnauthorizedOperation(ref cause) => cause,
DisassociateDiscoveredResourceError::Validation(ref cause) => cause,
DisassociateDiscoveredResourceError::Credentials(ref err) => err.description(),
DisassociateDiscoveredResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DisassociateDiscoveredResourceError::ParseError(ref cause) => cause,
DisassociateDiscoveredResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ImportMigrationTaskError {
AccessDenied(String),
DryRunOperation(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ImportMigrationTaskError {
pub fn from_response(res: BufferedHttpResponse) -> ImportMigrationTaskError {
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 {
"AccessDeniedException" => {
return ImportMigrationTaskError::AccessDenied(String::from(error_message));
}
"DryRunOperation" => {
return ImportMigrationTaskError::DryRunOperation(String::from(error_message));
}
"InternalServerError" => {
return ImportMigrationTaskError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return ImportMigrationTaskError::InvalidInput(String::from(error_message));
}
"ResourceNotFoundException" => {
return ImportMigrationTaskError::ResourceNotFound(String::from(error_message));
}
"ServiceUnavailableException" => {
return ImportMigrationTaskError::ServiceUnavailable(String::from(error_message));
}
"UnauthorizedOperation" => {
return ImportMigrationTaskError::UnauthorizedOperation(String::from(
error_message,
));
}
"ValidationException" => {
return ImportMigrationTaskError::Validation(error_message.to_string());
}
_ => {}
}
}
return ImportMigrationTaskError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ImportMigrationTaskError {
fn from(err: serde_json::error::Error) -> ImportMigrationTaskError {
ImportMigrationTaskError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ImportMigrationTaskError {
fn from(err: CredentialsError) -> ImportMigrationTaskError {
ImportMigrationTaskError::Credentials(err)
}
}
impl From<HttpDispatchError> for ImportMigrationTaskError {
fn from(err: HttpDispatchError) -> ImportMigrationTaskError {
ImportMigrationTaskError::HttpDispatch(err)
}
}
impl From<io::Error> for ImportMigrationTaskError {
fn from(err: io::Error) -> ImportMigrationTaskError {
ImportMigrationTaskError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ImportMigrationTaskError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ImportMigrationTaskError {
fn description(&self) -> &str {
match *self {
ImportMigrationTaskError::AccessDenied(ref cause) => cause,
ImportMigrationTaskError::DryRunOperation(ref cause) => cause,
ImportMigrationTaskError::InternalServerError(ref cause) => cause,
ImportMigrationTaskError::InvalidInput(ref cause) => cause,
ImportMigrationTaskError::ResourceNotFound(ref cause) => cause,
ImportMigrationTaskError::ServiceUnavailable(ref cause) => cause,
ImportMigrationTaskError::UnauthorizedOperation(ref cause) => cause,
ImportMigrationTaskError::Validation(ref cause) => cause,
ImportMigrationTaskError::Credentials(ref err) => err.description(),
ImportMigrationTaskError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ImportMigrationTaskError::ParseError(ref cause) => cause,
ImportMigrationTaskError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListCreatedArtifactsError {
AccessDenied(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListCreatedArtifactsError {
pub fn from_response(res: BufferedHttpResponse) -> ListCreatedArtifactsError {
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 {
"AccessDeniedException" => {
return ListCreatedArtifactsError::AccessDenied(String::from(error_message));
}
"InternalServerError" => {
return ListCreatedArtifactsError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return ListCreatedArtifactsError::InvalidInput(String::from(error_message));
}
"ResourceNotFoundException" => {
return ListCreatedArtifactsError::ResourceNotFound(String::from(error_message));
}
"ServiceUnavailableException" => {
return ListCreatedArtifactsError::ServiceUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return ListCreatedArtifactsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListCreatedArtifactsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListCreatedArtifactsError {
fn from(err: serde_json::error::Error) -> ListCreatedArtifactsError {
ListCreatedArtifactsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListCreatedArtifactsError {
fn from(err: CredentialsError) -> ListCreatedArtifactsError {
ListCreatedArtifactsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListCreatedArtifactsError {
fn from(err: HttpDispatchError) -> ListCreatedArtifactsError {
ListCreatedArtifactsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListCreatedArtifactsError {
fn from(err: io::Error) -> ListCreatedArtifactsError {
ListCreatedArtifactsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListCreatedArtifactsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListCreatedArtifactsError {
fn description(&self) -> &str {
match *self {
ListCreatedArtifactsError::AccessDenied(ref cause) => cause,
ListCreatedArtifactsError::InternalServerError(ref cause) => cause,
ListCreatedArtifactsError::InvalidInput(ref cause) => cause,
ListCreatedArtifactsError::ResourceNotFound(ref cause) => cause,
ListCreatedArtifactsError::ServiceUnavailable(ref cause) => cause,
ListCreatedArtifactsError::Validation(ref cause) => cause,
ListCreatedArtifactsError::Credentials(ref err) => err.description(),
ListCreatedArtifactsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListCreatedArtifactsError::ParseError(ref cause) => cause,
ListCreatedArtifactsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListDiscoveredResourcesError {
AccessDenied(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListDiscoveredResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> ListDiscoveredResourcesError {
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 {
"AccessDeniedException" => {
return ListDiscoveredResourcesError::AccessDenied(String::from(error_message));
}
"InternalServerError" => {
return ListDiscoveredResourcesError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return ListDiscoveredResourcesError::InvalidInput(String::from(error_message));
}
"ResourceNotFoundException" => {
return ListDiscoveredResourcesError::ResourceNotFound(String::from(
error_message,
));
}
"ServiceUnavailableException" => {
return ListDiscoveredResourcesError::ServiceUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return ListDiscoveredResourcesError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListDiscoveredResourcesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListDiscoveredResourcesError {
fn from(err: serde_json::error::Error) -> ListDiscoveredResourcesError {
ListDiscoveredResourcesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListDiscoveredResourcesError {
fn from(err: CredentialsError) -> ListDiscoveredResourcesError {
ListDiscoveredResourcesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListDiscoveredResourcesError {
fn from(err: HttpDispatchError) -> ListDiscoveredResourcesError {
ListDiscoveredResourcesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListDiscoveredResourcesError {
fn from(err: io::Error) -> ListDiscoveredResourcesError {
ListDiscoveredResourcesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListDiscoveredResourcesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListDiscoveredResourcesError {
fn description(&self) -> &str {
match *self {
ListDiscoveredResourcesError::AccessDenied(ref cause) => cause,
ListDiscoveredResourcesError::InternalServerError(ref cause) => cause,
ListDiscoveredResourcesError::InvalidInput(ref cause) => cause,
ListDiscoveredResourcesError::ResourceNotFound(ref cause) => cause,
ListDiscoveredResourcesError::ServiceUnavailable(ref cause) => cause,
ListDiscoveredResourcesError::Validation(ref cause) => cause,
ListDiscoveredResourcesError::Credentials(ref err) => err.description(),
ListDiscoveredResourcesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListDiscoveredResourcesError::ParseError(ref cause) => cause,
ListDiscoveredResourcesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListMigrationTasksError {
AccessDenied(String),
InternalServerError(String),
InvalidInput(String),
PolicyError(String),
ResourceNotFound(String),
ServiceUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListMigrationTasksError {
pub fn from_response(res: BufferedHttpResponse) -> ListMigrationTasksError {
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 {
"AccessDeniedException" => {
return ListMigrationTasksError::AccessDenied(String::from(error_message));
}
"InternalServerError" => {
return ListMigrationTasksError::InternalServerError(String::from(error_message));
}
"InvalidInputException" => {
return ListMigrationTasksError::InvalidInput(String::from(error_message));
}
"PolicyErrorException" => {
return ListMigrationTasksError::PolicyError(String::from(error_message));
}
"ResourceNotFoundException" => {
return ListMigrationTasksError::ResourceNotFound(String::from(error_message));
}
"ServiceUnavailableException" => {
return ListMigrationTasksError::ServiceUnavailable(String::from(error_message));
}
"ValidationException" => {
return ListMigrationTasksError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListMigrationTasksError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListMigrationTasksError {
fn from(err: serde_json::error::Error) -> ListMigrationTasksError {
ListMigrationTasksError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListMigrationTasksError {
fn from(err: CredentialsError) -> ListMigrationTasksError {
ListMigrationTasksError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListMigrationTasksError {
fn from(err: HttpDispatchError) -> ListMigrationTasksError {
ListMigrationTasksError::HttpDispatch(err)
}
}
impl From<io::Error> for ListMigrationTasksError {
fn from(err: io::Error) -> ListMigrationTasksError {
ListMigrationTasksError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListMigrationTasksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListMigrationTasksError {
fn description(&self) -> &str {
match *self {
ListMigrationTasksError::AccessDenied(ref cause) => cause,
ListMigrationTasksError::InternalServerError(ref cause) => cause,
ListMigrationTasksError::InvalidInput(ref cause) => cause,
ListMigrationTasksError::PolicyError(ref cause) => cause,
ListMigrationTasksError::ResourceNotFound(ref cause) => cause,
ListMigrationTasksError::ServiceUnavailable(ref cause) => cause,
ListMigrationTasksError::Validation(ref cause) => cause,
ListMigrationTasksError::Credentials(ref err) => err.description(),
ListMigrationTasksError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListMigrationTasksError::ParseError(ref cause) => cause,
ListMigrationTasksError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListProgressUpdateStreamsError {
AccessDenied(String),
InternalServerError(String),
InvalidInput(String),
ServiceUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListProgressUpdateStreamsError {
pub fn from_response(res: BufferedHttpResponse) -> ListProgressUpdateStreamsError {
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 {
"AccessDeniedException" => {
return ListProgressUpdateStreamsError::AccessDenied(String::from(error_message));
}
"InternalServerError" => {
return ListProgressUpdateStreamsError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return ListProgressUpdateStreamsError::InvalidInput(String::from(error_message));
}
"ServiceUnavailableException" => {
return ListProgressUpdateStreamsError::ServiceUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return ListProgressUpdateStreamsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListProgressUpdateStreamsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListProgressUpdateStreamsError {
fn from(err: serde_json::error::Error) -> ListProgressUpdateStreamsError {
ListProgressUpdateStreamsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListProgressUpdateStreamsError {
fn from(err: CredentialsError) -> ListProgressUpdateStreamsError {
ListProgressUpdateStreamsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListProgressUpdateStreamsError {
fn from(err: HttpDispatchError) -> ListProgressUpdateStreamsError {
ListProgressUpdateStreamsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListProgressUpdateStreamsError {
fn from(err: io::Error) -> ListProgressUpdateStreamsError {
ListProgressUpdateStreamsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListProgressUpdateStreamsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListProgressUpdateStreamsError {
fn description(&self) -> &str {
match *self {
ListProgressUpdateStreamsError::AccessDenied(ref cause) => cause,
ListProgressUpdateStreamsError::InternalServerError(ref cause) => cause,
ListProgressUpdateStreamsError::InvalidInput(ref cause) => cause,
ListProgressUpdateStreamsError::ServiceUnavailable(ref cause) => cause,
ListProgressUpdateStreamsError::Validation(ref cause) => cause,
ListProgressUpdateStreamsError::Credentials(ref err) => err.description(),
ListProgressUpdateStreamsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListProgressUpdateStreamsError::ParseError(ref cause) => cause,
ListProgressUpdateStreamsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum NotifyApplicationStateError {
AccessDenied(String),
DryRunOperation(String),
InternalServerError(String),
InvalidInput(String),
PolicyError(String),
ResourceNotFound(String),
ServiceUnavailable(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl NotifyApplicationStateError {
pub fn from_response(res: BufferedHttpResponse) -> NotifyApplicationStateError {
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 {
"AccessDeniedException" => {
return NotifyApplicationStateError::AccessDenied(String::from(error_message));
}
"DryRunOperation" => {
return NotifyApplicationStateError::DryRunOperation(String::from(error_message));
}
"InternalServerError" => {
return NotifyApplicationStateError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return NotifyApplicationStateError::InvalidInput(String::from(error_message));
}
"PolicyErrorException" => {
return NotifyApplicationStateError::PolicyError(String::from(error_message));
}
"ResourceNotFoundException" => {
return NotifyApplicationStateError::ResourceNotFound(String::from(
error_message,
));
}
"ServiceUnavailableException" => {
return NotifyApplicationStateError::ServiceUnavailable(String::from(
error_message,
));
}
"UnauthorizedOperation" => {
return NotifyApplicationStateError::UnauthorizedOperation(String::from(
error_message,
));
}
"ValidationException" => {
return NotifyApplicationStateError::Validation(error_message.to_string());
}
_ => {}
}
}
return NotifyApplicationStateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for NotifyApplicationStateError {
fn from(err: serde_json::error::Error) -> NotifyApplicationStateError {
NotifyApplicationStateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for NotifyApplicationStateError {
fn from(err: CredentialsError) -> NotifyApplicationStateError {
NotifyApplicationStateError::Credentials(err)
}
}
impl From<HttpDispatchError> for NotifyApplicationStateError {
fn from(err: HttpDispatchError) -> NotifyApplicationStateError {
NotifyApplicationStateError::HttpDispatch(err)
}
}
impl From<io::Error> for NotifyApplicationStateError {
fn from(err: io::Error) -> NotifyApplicationStateError {
NotifyApplicationStateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for NotifyApplicationStateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for NotifyApplicationStateError {
fn description(&self) -> &str {
match *self {
NotifyApplicationStateError::AccessDenied(ref cause) => cause,
NotifyApplicationStateError::DryRunOperation(ref cause) => cause,
NotifyApplicationStateError::InternalServerError(ref cause) => cause,
NotifyApplicationStateError::InvalidInput(ref cause) => cause,
NotifyApplicationStateError::PolicyError(ref cause) => cause,
NotifyApplicationStateError::ResourceNotFound(ref cause) => cause,
NotifyApplicationStateError::ServiceUnavailable(ref cause) => cause,
NotifyApplicationStateError::UnauthorizedOperation(ref cause) => cause,
NotifyApplicationStateError::Validation(ref cause) => cause,
NotifyApplicationStateError::Credentials(ref err) => err.description(),
NotifyApplicationStateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
NotifyApplicationStateError::ParseError(ref cause) => cause,
NotifyApplicationStateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum NotifyMigrationTaskStateError {
AccessDenied(String),
DryRunOperation(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl NotifyMigrationTaskStateError {
pub fn from_response(res: BufferedHttpResponse) -> NotifyMigrationTaskStateError {
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 {
"AccessDeniedException" => {
return NotifyMigrationTaskStateError::AccessDenied(String::from(error_message));
}
"DryRunOperation" => {
return NotifyMigrationTaskStateError::DryRunOperation(String::from(
error_message,
));
}
"InternalServerError" => {
return NotifyMigrationTaskStateError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return NotifyMigrationTaskStateError::InvalidInput(String::from(error_message));
}
"ResourceNotFoundException" => {
return NotifyMigrationTaskStateError::ResourceNotFound(String::from(
error_message,
));
}
"ServiceUnavailableException" => {
return NotifyMigrationTaskStateError::ServiceUnavailable(String::from(
error_message,
));
}
"UnauthorizedOperation" => {
return NotifyMigrationTaskStateError::UnauthorizedOperation(String::from(
error_message,
));
}
"ValidationException" => {
return NotifyMigrationTaskStateError::Validation(error_message.to_string());
}
_ => {}
}
}
return NotifyMigrationTaskStateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for NotifyMigrationTaskStateError {
fn from(err: serde_json::error::Error) -> NotifyMigrationTaskStateError {
NotifyMigrationTaskStateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for NotifyMigrationTaskStateError {
fn from(err: CredentialsError) -> NotifyMigrationTaskStateError {
NotifyMigrationTaskStateError::Credentials(err)
}
}
impl From<HttpDispatchError> for NotifyMigrationTaskStateError {
fn from(err: HttpDispatchError) -> NotifyMigrationTaskStateError {
NotifyMigrationTaskStateError::HttpDispatch(err)
}
}
impl From<io::Error> for NotifyMigrationTaskStateError {
fn from(err: io::Error) -> NotifyMigrationTaskStateError {
NotifyMigrationTaskStateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for NotifyMigrationTaskStateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for NotifyMigrationTaskStateError {
fn description(&self) -> &str {
match *self {
NotifyMigrationTaskStateError::AccessDenied(ref cause) => cause,
NotifyMigrationTaskStateError::DryRunOperation(ref cause) => cause,
NotifyMigrationTaskStateError::InternalServerError(ref cause) => cause,
NotifyMigrationTaskStateError::InvalidInput(ref cause) => cause,
NotifyMigrationTaskStateError::ResourceNotFound(ref cause) => cause,
NotifyMigrationTaskStateError::ServiceUnavailable(ref cause) => cause,
NotifyMigrationTaskStateError::UnauthorizedOperation(ref cause) => cause,
NotifyMigrationTaskStateError::Validation(ref cause) => cause,
NotifyMigrationTaskStateError::Credentials(ref err) => err.description(),
NotifyMigrationTaskStateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
NotifyMigrationTaskStateError::ParseError(ref cause) => cause,
NotifyMigrationTaskStateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum PutResourceAttributesError {
AccessDenied(String),
DryRunOperation(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
UnauthorizedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PutResourceAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> PutResourceAttributesError {
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 {
"AccessDeniedException" => {
return PutResourceAttributesError::AccessDenied(String::from(error_message));
}
"DryRunOperation" => {
return PutResourceAttributesError::DryRunOperation(String::from(error_message));
}
"InternalServerError" => {
return PutResourceAttributesError::InternalServerError(String::from(
error_message,
));
}
"InvalidInputException" => {
return PutResourceAttributesError::InvalidInput(String::from(error_message));
}
"ResourceNotFoundException" => {
return PutResourceAttributesError::ResourceNotFound(String::from(error_message));
}
"ServiceUnavailableException" => {
return PutResourceAttributesError::ServiceUnavailable(String::from(
error_message,
));
}
"UnauthorizedOperation" => {
return PutResourceAttributesError::UnauthorizedOperation(String::from(
error_message,
));
}
"ValidationException" => {
return PutResourceAttributesError::Validation(error_message.to_string());
}
_ => {}
}
}
return PutResourceAttributesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for PutResourceAttributesError {
fn from(err: serde_json::error::Error) -> PutResourceAttributesError {
PutResourceAttributesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for PutResourceAttributesError {
fn from(err: CredentialsError) -> PutResourceAttributesError {
PutResourceAttributesError::Credentials(err)
}
}
impl From<HttpDispatchError> for PutResourceAttributesError {
fn from(err: HttpDispatchError) -> PutResourceAttributesError {
PutResourceAttributesError::HttpDispatch(err)
}
}
impl From<io::Error> for PutResourceAttributesError {
fn from(err: io::Error) -> PutResourceAttributesError {
PutResourceAttributesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PutResourceAttributesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PutResourceAttributesError {
fn description(&self) -> &str {
match *self {
PutResourceAttributesError::AccessDenied(ref cause) => cause,
PutResourceAttributesError::DryRunOperation(ref cause) => cause,
PutResourceAttributesError::InternalServerError(ref cause) => cause,
PutResourceAttributesError::InvalidInput(ref cause) => cause,
PutResourceAttributesError::ResourceNotFound(ref cause) => cause,
PutResourceAttributesError::ServiceUnavailable(ref cause) => cause,
PutResourceAttributesError::UnauthorizedOperation(ref cause) => cause,
PutResourceAttributesError::Validation(ref cause) => cause,
PutResourceAttributesError::Credentials(ref err) => err.description(),
PutResourceAttributesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
PutResourceAttributesError::ParseError(ref cause) => cause,
PutResourceAttributesError::Unknown(_) => "unknown error",
}
}
}
pub trait MigrationHub {
fn associate_created_artifact(
&self,
input: AssociateCreatedArtifactRequest,
) -> RusotoFuture<AssociateCreatedArtifactResult, AssociateCreatedArtifactError>;
fn associate_discovered_resource(
&self,
input: AssociateDiscoveredResourceRequest,
) -> RusotoFuture<AssociateDiscoveredResourceResult, AssociateDiscoveredResourceError>;
fn create_progress_update_stream(
&self,
input: CreateProgressUpdateStreamRequest,
) -> RusotoFuture<CreateProgressUpdateStreamResult, CreateProgressUpdateStreamError>;
fn delete_progress_update_stream(
&self,
input: DeleteProgressUpdateStreamRequest,
) -> RusotoFuture<DeleteProgressUpdateStreamResult, DeleteProgressUpdateStreamError>;
fn describe_application_state(
&self,
input: DescribeApplicationStateRequest,
) -> RusotoFuture<DescribeApplicationStateResult, DescribeApplicationStateError>;
fn describe_migration_task(
&self,
input: DescribeMigrationTaskRequest,
) -> RusotoFuture<DescribeMigrationTaskResult, DescribeMigrationTaskError>;
fn disassociate_created_artifact(
&self,
input: DisassociateCreatedArtifactRequest,
) -> RusotoFuture<DisassociateCreatedArtifactResult, DisassociateCreatedArtifactError>;
fn disassociate_discovered_resource(
&self,
input: DisassociateDiscoveredResourceRequest,
) -> RusotoFuture<DisassociateDiscoveredResourceResult, DisassociateDiscoveredResourceError>;
fn import_migration_task(
&self,
input: ImportMigrationTaskRequest,
) -> RusotoFuture<ImportMigrationTaskResult, ImportMigrationTaskError>;
fn list_created_artifacts(
&self,
input: ListCreatedArtifactsRequest,
) -> RusotoFuture<ListCreatedArtifactsResult, ListCreatedArtifactsError>;
fn list_discovered_resources(
&self,
input: ListDiscoveredResourcesRequest,
) -> RusotoFuture<ListDiscoveredResourcesResult, ListDiscoveredResourcesError>;
fn list_migration_tasks(
&self,
input: ListMigrationTasksRequest,
) -> RusotoFuture<ListMigrationTasksResult, ListMigrationTasksError>;
fn list_progress_update_streams(
&self,
input: ListProgressUpdateStreamsRequest,
) -> RusotoFuture<ListProgressUpdateStreamsResult, ListProgressUpdateStreamsError>;
fn notify_application_state(
&self,
input: NotifyApplicationStateRequest,
) -> RusotoFuture<NotifyApplicationStateResult, NotifyApplicationStateError>;
fn notify_migration_task_state(
&self,
input: NotifyMigrationTaskStateRequest,
) -> RusotoFuture<NotifyMigrationTaskStateResult, NotifyMigrationTaskStateError>;
fn put_resource_attributes(
&self,
input: PutResourceAttributesRequest,
) -> RusotoFuture<PutResourceAttributesResult, PutResourceAttributesError>;
}
#[derive(Clone)]
pub struct MigrationHubClient {
client: Client,
region: region::Region,
}
impl MigrationHubClient {
pub fn new(region: region::Region) -> MigrationHubClient {
MigrationHubClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> MigrationHubClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
MigrationHubClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl MigrationHub for MigrationHubClient {
fn associate_created_artifact(
&self,
input: AssociateCreatedArtifactRequest,
) -> RusotoFuture<AssociateCreatedArtifactResult, AssociateCreatedArtifactError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSMigrationHub.AssociateCreatedArtifact");
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::<AssociateCreatedArtifactResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(AssociateCreatedArtifactError::from_response(response))
}))
}
})
}
fn associate_discovered_resource(
&self,
input: AssociateDiscoveredResourceRequest,
) -> RusotoFuture<AssociateDiscoveredResourceResult, AssociateDiscoveredResourceError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSMigrationHub.AssociateDiscoveredResource",
);
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::<AssociateDiscoveredResourceResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(AssociateDiscoveredResourceError::from_response(response))
}))
}
})
}
fn create_progress_update_stream(
&self,
input: CreateProgressUpdateStreamRequest,
) -> RusotoFuture<CreateProgressUpdateStreamResult, CreateProgressUpdateStreamError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSMigrationHub.CreateProgressUpdateStream");
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::<CreateProgressUpdateStreamResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateProgressUpdateStreamError::from_response(response))
}))
}
})
}
fn delete_progress_update_stream(
&self,
input: DeleteProgressUpdateStreamRequest,
) -> RusotoFuture<DeleteProgressUpdateStreamResult, DeleteProgressUpdateStreamError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSMigrationHub.DeleteProgressUpdateStream");
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::<DeleteProgressUpdateStreamResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteProgressUpdateStreamError::from_response(response))
}))
}
})
}
fn describe_application_state(
&self,
input: DescribeApplicationStateRequest,
) -> RusotoFuture<DescribeApplicationStateResult, DescribeApplicationStateError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSMigrationHub.DescribeApplicationState");
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::<DescribeApplicationStateResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeApplicationStateError::from_response(response))
}))
}
})
}
fn describe_migration_task(
&self,
input: DescribeMigrationTaskRequest,
) -> RusotoFuture<DescribeMigrationTaskResult, DescribeMigrationTaskError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSMigrationHub.DescribeMigrationTask");
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::<DescribeMigrationTaskResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeMigrationTaskError::from_response(response))
}),
)
}
})
}
fn disassociate_created_artifact(
&self,
input: DisassociateCreatedArtifactRequest,
) -> RusotoFuture<DisassociateCreatedArtifactResult, DisassociateCreatedArtifactError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSMigrationHub.DisassociateCreatedArtifact",
);
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::<DisassociateCreatedArtifactResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateCreatedArtifactError::from_response(response))
}))
}
})
}
fn disassociate_discovered_resource(
&self,
input: DisassociateDiscoveredResourceRequest,
) -> RusotoFuture<DisassociateDiscoveredResourceResult, DisassociateDiscoveredResourceError>
{
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSMigrationHub.DisassociateDiscoveredResource",
);
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::<DisassociateDiscoveredResourceResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateDiscoveredResourceError::from_response(response))
}))
}
})
}
fn import_migration_task(
&self,
input: ImportMigrationTaskRequest,
) -> RusotoFuture<ImportMigrationTaskResult, ImportMigrationTaskError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSMigrationHub.ImportMigrationTask");
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::<ImportMigrationTaskResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ImportMigrationTaskError::from_response(response))
}),
)
}
})
}
fn list_created_artifacts(
&self,
input: ListCreatedArtifactsRequest,
) -> RusotoFuture<ListCreatedArtifactsResult, ListCreatedArtifactsError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSMigrationHub.ListCreatedArtifacts");
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::<ListCreatedArtifactsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListCreatedArtifactsError::from_response(response))
}),
)
}
})
}
fn list_discovered_resources(
&self,
input: ListDiscoveredResourcesRequest,
) -> RusotoFuture<ListDiscoveredResourcesResult, ListDiscoveredResourcesError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSMigrationHub.ListDiscoveredResources");
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::<ListDiscoveredResourcesResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListDiscoveredResourcesError::from_response(response))
}))
}
})
}
fn list_migration_tasks(
&self,
input: ListMigrationTasksRequest,
) -> RusotoFuture<ListMigrationTasksResult, ListMigrationTasksError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSMigrationHub.ListMigrationTasks");
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::<ListMigrationTasksResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListMigrationTasksError::from_response(response))),
)
}
})
}
fn list_progress_update_streams(
&self,
input: ListProgressUpdateStreamsRequest,
) -> RusotoFuture<ListProgressUpdateStreamsResult, ListProgressUpdateStreamsError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSMigrationHub.ListProgressUpdateStreams");
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::<ListProgressUpdateStreamsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListProgressUpdateStreamsError::from_response(response))
}))
}
})
}
fn notify_application_state(
&self,
input: NotifyApplicationStateRequest,
) -> RusotoFuture<NotifyApplicationStateResult, NotifyApplicationStateError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSMigrationHub.NotifyApplicationState");
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::<NotifyApplicationStateResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(NotifyApplicationStateError::from_response(response))
}),
)
}
})
}
fn notify_migration_task_state(
&self,
input: NotifyMigrationTaskStateRequest,
) -> RusotoFuture<NotifyMigrationTaskStateResult, NotifyMigrationTaskStateError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSMigrationHub.NotifyMigrationTaskState");
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::<NotifyMigrationTaskStateResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(NotifyMigrationTaskStateError::from_response(response))
}))
}
})
}
fn put_resource_attributes(
&self,
input: PutResourceAttributesRequest,
) -> RusotoFuture<PutResourceAttributesResult, PutResourceAttributesError> {
let mut request = SignedRequest::new("POST", "mgh", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSMigrationHub.PutResourceAttributes");
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::<PutResourceAttributesResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(PutResourceAttributesError::from_response(response))
}),
)
}
})
}
}
#[cfg(test)]
mod protocol_tests {}