use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl MigrationHubClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "mgh", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApplicationState {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[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(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateCreatedArtifactResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateDiscoveredResourceResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateProgressUpdateStreamResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CreatedArtifact {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteProgressUpdateStreamResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeApplicationStateRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), 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(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeMigrationTaskRequest {
#[serde(rename = "MigrationTaskName")]
pub migration_task_name: String,
#[serde(rename = "ProgressUpdateStream")]
pub progress_update_stream: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeMigrationTaskResult {
#[serde(rename = "MigrationTask")]
#[serde(skip_serializing_if = "Option::is_none")]
pub migration_task: Option<MigrationTask>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateCreatedArtifactResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateDiscoveredResourceResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
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(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImportMigrationTaskResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListApplicationStatesRequest {
#[serde(rename = "ApplicationIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_ids: Option<Vec<String>>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListApplicationStatesResult {
#[serde(rename = "ApplicationStateList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_state_list: Option<Vec<ApplicationState>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct 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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), 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(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), 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(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), 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(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), 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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), 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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), 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(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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,
#[serde(rename = "UpdateDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_date_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NotifyApplicationStateResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NotifyMigrationTaskStateResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProgressUpdateStreamSummary {
#[serde(rename = "ProgressUpdateStreamName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub progress_update_stream_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutResourceAttributesResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResourceAttribute {
#[serde(rename = "Type")]
pub type_: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
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),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
UnauthorizedOperation(String),
}
impl AssociateCreatedArtifactError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateCreatedArtifactError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AssociateCreatedArtifactError::AccessDenied(
err.msg,
))
}
"DryRunOperation" => {
return RusotoError::Service(AssociateCreatedArtifactError::DryRunOperation(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(AssociateCreatedArtifactError::HomeRegionNotSet(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(
AssociateCreatedArtifactError::InternalServerError(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(AssociateCreatedArtifactError::InvalidInput(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AssociateCreatedArtifactError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(AssociateCreatedArtifactError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(AssociateCreatedArtifactError::Throttling(err.msg))
}
"UnauthorizedOperation" => {
return RusotoError::Service(
AssociateCreatedArtifactError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateCreatedArtifactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateCreatedArtifactError::AccessDenied(ref cause) => write!(f, "{}", cause),
AssociateCreatedArtifactError::DryRunOperation(ref cause) => write!(f, "{}", cause),
AssociateCreatedArtifactError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
AssociateCreatedArtifactError::InternalServerError(ref cause) => write!(f, "{}", cause),
AssociateCreatedArtifactError::InvalidInput(ref cause) => write!(f, "{}", cause),
AssociateCreatedArtifactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AssociateCreatedArtifactError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
AssociateCreatedArtifactError::Throttling(ref cause) => write!(f, "{}", cause),
AssociateCreatedArtifactError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateCreatedArtifactError {}
#[derive(Debug, PartialEq)]
pub enum AssociateDiscoveredResourceError {
AccessDenied(String),
DryRunOperation(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
PolicyError(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
UnauthorizedOperation(String),
}
impl AssociateDiscoveredResourceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateDiscoveredResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AssociateDiscoveredResourceError::AccessDenied(
err.msg,
))
}
"DryRunOperation" => {
return RusotoError::Service(AssociateDiscoveredResourceError::DryRunOperation(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(
AssociateDiscoveredResourceError::HomeRegionNotSet(err.msg),
)
}
"InternalServerError" => {
return RusotoError::Service(
AssociateDiscoveredResourceError::InternalServerError(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(AssociateDiscoveredResourceError::InvalidInput(
err.msg,
))
}
"PolicyErrorException" => {
return RusotoError::Service(AssociateDiscoveredResourceError::PolicyError(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AssociateDiscoveredResourceError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
AssociateDiscoveredResourceError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(AssociateDiscoveredResourceError::Throttling(
err.msg,
))
}
"UnauthorizedOperation" => {
return RusotoError::Service(
AssociateDiscoveredResourceError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateDiscoveredResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateDiscoveredResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
AssociateDiscoveredResourceError::DryRunOperation(ref cause) => write!(f, "{}", cause),
AssociateDiscoveredResourceError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
AssociateDiscoveredResourceError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
AssociateDiscoveredResourceError::InvalidInput(ref cause) => write!(f, "{}", cause),
AssociateDiscoveredResourceError::PolicyError(ref cause) => write!(f, "{}", cause),
AssociateDiscoveredResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AssociateDiscoveredResourceError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
AssociateDiscoveredResourceError::Throttling(ref cause) => write!(f, "{}", cause),
AssociateDiscoveredResourceError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateDiscoveredResourceError {}
#[derive(Debug, PartialEq)]
pub enum CreateProgressUpdateStreamError {
AccessDenied(String),
DryRunOperation(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
ServiceUnavailable(String),
Throttling(String),
UnauthorizedOperation(String),
}
impl CreateProgressUpdateStreamError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateProgressUpdateStreamError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateProgressUpdateStreamError::AccessDenied(
err.msg,
))
}
"DryRunOperation" => {
return RusotoError::Service(CreateProgressUpdateStreamError::DryRunOperation(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(CreateProgressUpdateStreamError::HomeRegionNotSet(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(
CreateProgressUpdateStreamError::InternalServerError(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(CreateProgressUpdateStreamError::InvalidInput(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
CreateProgressUpdateStreamError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(CreateProgressUpdateStreamError::Throttling(
err.msg,
))
}
"UnauthorizedOperation" => {
return RusotoError::Service(
CreateProgressUpdateStreamError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateProgressUpdateStreamError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateProgressUpdateStreamError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateProgressUpdateStreamError::DryRunOperation(ref cause) => write!(f, "{}", cause),
CreateProgressUpdateStreamError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
CreateProgressUpdateStreamError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
CreateProgressUpdateStreamError::InvalidInput(ref cause) => write!(f, "{}", cause),
CreateProgressUpdateStreamError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
CreateProgressUpdateStreamError::Throttling(ref cause) => write!(f, "{}", cause),
CreateProgressUpdateStreamError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateProgressUpdateStreamError {}
#[derive(Debug, PartialEq)]
pub enum DeleteProgressUpdateStreamError {
AccessDenied(String),
DryRunOperation(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
UnauthorizedOperation(String),
}
impl DeleteProgressUpdateStreamError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteProgressUpdateStreamError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteProgressUpdateStreamError::AccessDenied(
err.msg,
))
}
"DryRunOperation" => {
return RusotoError::Service(DeleteProgressUpdateStreamError::DryRunOperation(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(DeleteProgressUpdateStreamError::HomeRegionNotSet(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(
DeleteProgressUpdateStreamError::InternalServerError(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(DeleteProgressUpdateStreamError::InvalidInput(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteProgressUpdateStreamError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
DeleteProgressUpdateStreamError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(DeleteProgressUpdateStreamError::Throttling(
err.msg,
))
}
"UnauthorizedOperation" => {
return RusotoError::Service(
DeleteProgressUpdateStreamError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteProgressUpdateStreamError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteProgressUpdateStreamError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteProgressUpdateStreamError::DryRunOperation(ref cause) => write!(f, "{}", cause),
DeleteProgressUpdateStreamError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
DeleteProgressUpdateStreamError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DeleteProgressUpdateStreamError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeleteProgressUpdateStreamError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteProgressUpdateStreamError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
DeleteProgressUpdateStreamError::Throttling(ref cause) => write!(f, "{}", cause),
DeleteProgressUpdateStreamError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteProgressUpdateStreamError {}
#[derive(Debug, PartialEq)]
pub enum DescribeApplicationStateError {
AccessDenied(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
PolicyError(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl DescribeApplicationStateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeApplicationStateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeApplicationStateError::AccessDenied(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(DescribeApplicationStateError::HomeRegionNotSet(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(
DescribeApplicationStateError::InternalServerError(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(DescribeApplicationStateError::InvalidInput(
err.msg,
))
}
"PolicyErrorException" => {
return RusotoError::Service(DescribeApplicationStateError::PolicyError(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeApplicationStateError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeApplicationStateError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeApplicationStateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeApplicationStateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeApplicationStateError::AccessDenied(ref cause) => write!(f, "{}", cause),
DescribeApplicationStateError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
DescribeApplicationStateError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeApplicationStateError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeApplicationStateError::PolicyError(ref cause) => write!(f, "{}", cause),
DescribeApplicationStateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeApplicationStateError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DescribeApplicationStateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeApplicationStateError {}
#[derive(Debug, PartialEq)]
pub enum DescribeMigrationTaskError {
AccessDenied(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl DescribeMigrationTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeMigrationTaskError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeMigrationTaskError::AccessDenied(err.msg))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(DescribeMigrationTaskError::HomeRegionNotSet(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(DescribeMigrationTaskError::InternalServerError(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(DescribeMigrationTaskError::InvalidInput(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeMigrationTaskError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeMigrationTaskError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeMigrationTaskError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeMigrationTaskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeMigrationTaskError::AccessDenied(ref cause) => write!(f, "{}", cause),
DescribeMigrationTaskError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
DescribeMigrationTaskError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeMigrationTaskError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeMigrationTaskError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeMigrationTaskError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DescribeMigrationTaskError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeMigrationTaskError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateCreatedArtifactError {
AccessDenied(String),
DryRunOperation(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
UnauthorizedOperation(String),
}
impl DisassociateCreatedArtifactError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateCreatedArtifactError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DisassociateCreatedArtifactError::AccessDenied(
err.msg,
))
}
"DryRunOperation" => {
return RusotoError::Service(DisassociateCreatedArtifactError::DryRunOperation(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(
DisassociateCreatedArtifactError::HomeRegionNotSet(err.msg),
)
}
"InternalServerError" => {
return RusotoError::Service(
DisassociateCreatedArtifactError::InternalServerError(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(DisassociateCreatedArtifactError::InvalidInput(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DisassociateCreatedArtifactError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
DisassociateCreatedArtifactError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(DisassociateCreatedArtifactError::Throttling(
err.msg,
))
}
"UnauthorizedOperation" => {
return RusotoError::Service(
DisassociateCreatedArtifactError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateCreatedArtifactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateCreatedArtifactError::AccessDenied(ref cause) => write!(f, "{}", cause),
DisassociateCreatedArtifactError::DryRunOperation(ref cause) => write!(f, "{}", cause),
DisassociateCreatedArtifactError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
DisassociateCreatedArtifactError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DisassociateCreatedArtifactError::InvalidInput(ref cause) => write!(f, "{}", cause),
DisassociateCreatedArtifactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DisassociateCreatedArtifactError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
DisassociateCreatedArtifactError::Throttling(ref cause) => write!(f, "{}", cause),
DisassociateCreatedArtifactError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateCreatedArtifactError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateDiscoveredResourceError {
AccessDenied(String),
DryRunOperation(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
UnauthorizedOperation(String),
}
impl DisassociateDiscoveredResourceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateDiscoveredResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DisassociateDiscoveredResourceError::AccessDenied(
err.msg,
))
}
"DryRunOperation" => {
return RusotoError::Service(
DisassociateDiscoveredResourceError::DryRunOperation(err.msg),
)
}
"HomeRegionNotSetException" => {
return RusotoError::Service(
DisassociateDiscoveredResourceError::HomeRegionNotSet(err.msg),
)
}
"InternalServerError" => {
return RusotoError::Service(
DisassociateDiscoveredResourceError::InternalServerError(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(DisassociateDiscoveredResourceError::InvalidInput(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DisassociateDiscoveredResourceError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
DisassociateDiscoveredResourceError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(DisassociateDiscoveredResourceError::Throttling(
err.msg,
))
}
"UnauthorizedOperation" => {
return RusotoError::Service(
DisassociateDiscoveredResourceError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateDiscoveredResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateDiscoveredResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
DisassociateDiscoveredResourceError::DryRunOperation(ref cause) => {
write!(f, "{}", cause)
}
DisassociateDiscoveredResourceError::HomeRegionNotSet(ref cause) => {
write!(f, "{}", cause)
}
DisassociateDiscoveredResourceError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DisassociateDiscoveredResourceError::InvalidInput(ref cause) => write!(f, "{}", cause),
DisassociateDiscoveredResourceError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DisassociateDiscoveredResourceError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
DisassociateDiscoveredResourceError::Throttling(ref cause) => write!(f, "{}", cause),
DisassociateDiscoveredResourceError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateDiscoveredResourceError {}
#[derive(Debug, PartialEq)]
pub enum ImportMigrationTaskError {
AccessDenied(String),
DryRunOperation(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
UnauthorizedOperation(String),
}
impl ImportMigrationTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ImportMigrationTaskError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ImportMigrationTaskError::AccessDenied(err.msg))
}
"DryRunOperation" => {
return RusotoError::Service(ImportMigrationTaskError::DryRunOperation(err.msg))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(ImportMigrationTaskError::HomeRegionNotSet(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(ImportMigrationTaskError::InternalServerError(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(ImportMigrationTaskError::InvalidInput(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ImportMigrationTaskError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ImportMigrationTaskError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ImportMigrationTaskError::Throttling(err.msg))
}
"UnauthorizedOperation" => {
return RusotoError::Service(ImportMigrationTaskError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ImportMigrationTaskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ImportMigrationTaskError::AccessDenied(ref cause) => write!(f, "{}", cause),
ImportMigrationTaskError::DryRunOperation(ref cause) => write!(f, "{}", cause),
ImportMigrationTaskError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
ImportMigrationTaskError::InternalServerError(ref cause) => write!(f, "{}", cause),
ImportMigrationTaskError::InvalidInput(ref cause) => write!(f, "{}", cause),
ImportMigrationTaskError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ImportMigrationTaskError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ImportMigrationTaskError::Throttling(ref cause) => write!(f, "{}", cause),
ImportMigrationTaskError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ImportMigrationTaskError {}
#[derive(Debug, PartialEq)]
pub enum ListApplicationStatesError {
AccessDenied(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
ServiceUnavailable(String),
Throttling(String),
}
impl ListApplicationStatesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListApplicationStatesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListApplicationStatesError::AccessDenied(err.msg))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(ListApplicationStatesError::HomeRegionNotSet(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(ListApplicationStatesError::InternalServerError(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(ListApplicationStatesError::InvalidInput(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListApplicationStatesError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListApplicationStatesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListApplicationStatesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListApplicationStatesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListApplicationStatesError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
ListApplicationStatesError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListApplicationStatesError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListApplicationStatesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListApplicationStatesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListApplicationStatesError {}
#[derive(Debug, PartialEq)]
pub enum ListCreatedArtifactsError {
AccessDenied(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl ListCreatedArtifactsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListCreatedArtifactsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListCreatedArtifactsError::AccessDenied(err.msg))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(ListCreatedArtifactsError::HomeRegionNotSet(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(ListCreatedArtifactsError::InternalServerError(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(ListCreatedArtifactsError::InvalidInput(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListCreatedArtifactsError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListCreatedArtifactsError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListCreatedArtifactsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListCreatedArtifactsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListCreatedArtifactsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListCreatedArtifactsError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
ListCreatedArtifactsError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListCreatedArtifactsError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListCreatedArtifactsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListCreatedArtifactsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListCreatedArtifactsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListCreatedArtifactsError {}
#[derive(Debug, PartialEq)]
pub enum ListDiscoveredResourcesError {
AccessDenied(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl ListDiscoveredResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDiscoveredResourcesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListDiscoveredResourcesError::AccessDenied(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(ListDiscoveredResourcesError::HomeRegionNotSet(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(ListDiscoveredResourcesError::InternalServerError(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(ListDiscoveredResourcesError::InvalidInput(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListDiscoveredResourcesError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListDiscoveredResourcesError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListDiscoveredResourcesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDiscoveredResourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDiscoveredResourcesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListDiscoveredResourcesError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
ListDiscoveredResourcesError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListDiscoveredResourcesError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListDiscoveredResourcesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListDiscoveredResourcesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListDiscoveredResourcesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDiscoveredResourcesError {}
#[derive(Debug, PartialEq)]
pub enum ListMigrationTasksError {
AccessDenied(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
PolicyError(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl ListMigrationTasksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListMigrationTasksError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListMigrationTasksError::AccessDenied(err.msg))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(ListMigrationTasksError::HomeRegionNotSet(err.msg))
}
"InternalServerError" => {
return RusotoError::Service(ListMigrationTasksError::InternalServerError(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(ListMigrationTasksError::InvalidInput(err.msg))
}
"PolicyErrorException" => {
return RusotoError::Service(ListMigrationTasksError::PolicyError(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListMigrationTasksError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListMigrationTasksError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListMigrationTasksError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListMigrationTasksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListMigrationTasksError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListMigrationTasksError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
ListMigrationTasksError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListMigrationTasksError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListMigrationTasksError::PolicyError(ref cause) => write!(f, "{}", cause),
ListMigrationTasksError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListMigrationTasksError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListMigrationTasksError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListMigrationTasksError {}
#[derive(Debug, PartialEq)]
pub enum ListProgressUpdateStreamsError {
AccessDenied(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
ServiceUnavailable(String),
Throttling(String),
}
impl ListProgressUpdateStreamsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListProgressUpdateStreamsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListProgressUpdateStreamsError::AccessDenied(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(ListProgressUpdateStreamsError::HomeRegionNotSet(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(
ListProgressUpdateStreamsError::InternalServerError(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(ListProgressUpdateStreamsError::InvalidInput(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
ListProgressUpdateStreamsError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(ListProgressUpdateStreamsError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListProgressUpdateStreamsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListProgressUpdateStreamsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListProgressUpdateStreamsError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
ListProgressUpdateStreamsError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
ListProgressUpdateStreamsError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListProgressUpdateStreamsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListProgressUpdateStreamsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListProgressUpdateStreamsError {}
#[derive(Debug, PartialEq)]
pub enum NotifyApplicationStateError {
AccessDenied(String),
DryRunOperation(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
PolicyError(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
UnauthorizedOperation(String),
}
impl NotifyApplicationStateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<NotifyApplicationStateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(NotifyApplicationStateError::AccessDenied(err.msg))
}
"DryRunOperation" => {
return RusotoError::Service(NotifyApplicationStateError::DryRunOperation(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(NotifyApplicationStateError::HomeRegionNotSet(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(NotifyApplicationStateError::InternalServerError(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(NotifyApplicationStateError::InvalidInput(err.msg))
}
"PolicyErrorException" => {
return RusotoError::Service(NotifyApplicationStateError::PolicyError(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(NotifyApplicationStateError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(NotifyApplicationStateError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(NotifyApplicationStateError::Throttling(err.msg))
}
"UnauthorizedOperation" => {
return RusotoError::Service(
NotifyApplicationStateError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for NotifyApplicationStateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
NotifyApplicationStateError::AccessDenied(ref cause) => write!(f, "{}", cause),
NotifyApplicationStateError::DryRunOperation(ref cause) => write!(f, "{}", cause),
NotifyApplicationStateError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
NotifyApplicationStateError::InternalServerError(ref cause) => write!(f, "{}", cause),
NotifyApplicationStateError::InvalidInput(ref cause) => write!(f, "{}", cause),
NotifyApplicationStateError::PolicyError(ref cause) => write!(f, "{}", cause),
NotifyApplicationStateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
NotifyApplicationStateError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
NotifyApplicationStateError::Throttling(ref cause) => write!(f, "{}", cause),
NotifyApplicationStateError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for NotifyApplicationStateError {}
#[derive(Debug, PartialEq)]
pub enum NotifyMigrationTaskStateError {
AccessDenied(String),
DryRunOperation(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
UnauthorizedOperation(String),
}
impl NotifyMigrationTaskStateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<NotifyMigrationTaskStateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(NotifyMigrationTaskStateError::AccessDenied(
err.msg,
))
}
"DryRunOperation" => {
return RusotoError::Service(NotifyMigrationTaskStateError::DryRunOperation(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(NotifyMigrationTaskStateError::HomeRegionNotSet(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(
NotifyMigrationTaskStateError::InternalServerError(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(NotifyMigrationTaskStateError::InvalidInput(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(NotifyMigrationTaskStateError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(NotifyMigrationTaskStateError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(NotifyMigrationTaskStateError::Throttling(err.msg))
}
"UnauthorizedOperation" => {
return RusotoError::Service(
NotifyMigrationTaskStateError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for NotifyMigrationTaskStateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
NotifyMigrationTaskStateError::AccessDenied(ref cause) => write!(f, "{}", cause),
NotifyMigrationTaskStateError::DryRunOperation(ref cause) => write!(f, "{}", cause),
NotifyMigrationTaskStateError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
NotifyMigrationTaskStateError::InternalServerError(ref cause) => write!(f, "{}", cause),
NotifyMigrationTaskStateError::InvalidInput(ref cause) => write!(f, "{}", cause),
NotifyMigrationTaskStateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
NotifyMigrationTaskStateError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
NotifyMigrationTaskStateError::Throttling(ref cause) => write!(f, "{}", cause),
NotifyMigrationTaskStateError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for NotifyMigrationTaskStateError {}
#[derive(Debug, PartialEq)]
pub enum PutResourceAttributesError {
AccessDenied(String),
DryRunOperation(String),
HomeRegionNotSet(String),
InternalServerError(String),
InvalidInput(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
UnauthorizedOperation(String),
}
impl PutResourceAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutResourceAttributesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(PutResourceAttributesError::AccessDenied(err.msg))
}
"DryRunOperation" => {
return RusotoError::Service(PutResourceAttributesError::DryRunOperation(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(PutResourceAttributesError::HomeRegionNotSet(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(PutResourceAttributesError::InternalServerError(
err.msg,
))
}
"InvalidInputException" => {
return RusotoError::Service(PutResourceAttributesError::InvalidInput(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(PutResourceAttributesError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(PutResourceAttributesError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(PutResourceAttributesError::Throttling(err.msg))
}
"UnauthorizedOperation" => {
return RusotoError::Service(PutResourceAttributesError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutResourceAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutResourceAttributesError::AccessDenied(ref cause) => write!(f, "{}", cause),
PutResourceAttributesError::DryRunOperation(ref cause) => write!(f, "{}", cause),
PutResourceAttributesError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
PutResourceAttributesError::InternalServerError(ref cause) => write!(f, "{}", cause),
PutResourceAttributesError::InvalidInput(ref cause) => write!(f, "{}", cause),
PutResourceAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
PutResourceAttributesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
PutResourceAttributesError::Throttling(ref cause) => write!(f, "{}", cause),
PutResourceAttributesError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutResourceAttributesError {}
#[async_trait]
pub trait MigrationHub {
async fn associate_created_artifact(
&self,
input: AssociateCreatedArtifactRequest,
) -> Result<AssociateCreatedArtifactResult, RusotoError<AssociateCreatedArtifactError>>;
async fn associate_discovered_resource(
&self,
input: AssociateDiscoveredResourceRequest,
) -> Result<AssociateDiscoveredResourceResult, RusotoError<AssociateDiscoveredResourceError>>;
async fn create_progress_update_stream(
&self,
input: CreateProgressUpdateStreamRequest,
) -> Result<CreateProgressUpdateStreamResult, RusotoError<CreateProgressUpdateStreamError>>;
async fn delete_progress_update_stream(
&self,
input: DeleteProgressUpdateStreamRequest,
) -> Result<DeleteProgressUpdateStreamResult, RusotoError<DeleteProgressUpdateStreamError>>;
async fn describe_application_state(
&self,
input: DescribeApplicationStateRequest,
) -> Result<DescribeApplicationStateResult, RusotoError<DescribeApplicationStateError>>;
async fn describe_migration_task(
&self,
input: DescribeMigrationTaskRequest,
) -> Result<DescribeMigrationTaskResult, RusotoError<DescribeMigrationTaskError>>;
async fn disassociate_created_artifact(
&self,
input: DisassociateCreatedArtifactRequest,
) -> Result<DisassociateCreatedArtifactResult, RusotoError<DisassociateCreatedArtifactError>>;
async fn disassociate_discovered_resource(
&self,
input: DisassociateDiscoveredResourceRequest,
) -> Result<
DisassociateDiscoveredResourceResult,
RusotoError<DisassociateDiscoveredResourceError>,
>;
async fn import_migration_task(
&self,
input: ImportMigrationTaskRequest,
) -> Result<ImportMigrationTaskResult, RusotoError<ImportMigrationTaskError>>;
async fn list_application_states(
&self,
input: ListApplicationStatesRequest,
) -> Result<ListApplicationStatesResult, RusotoError<ListApplicationStatesError>>;
async fn list_created_artifacts(
&self,
input: ListCreatedArtifactsRequest,
) -> Result<ListCreatedArtifactsResult, RusotoError<ListCreatedArtifactsError>>;
async fn list_discovered_resources(
&self,
input: ListDiscoveredResourcesRequest,
) -> Result<ListDiscoveredResourcesResult, RusotoError<ListDiscoveredResourcesError>>;
async fn list_migration_tasks(
&self,
input: ListMigrationTasksRequest,
) -> Result<ListMigrationTasksResult, RusotoError<ListMigrationTasksError>>;
async fn list_progress_update_streams(
&self,
input: ListProgressUpdateStreamsRequest,
) -> Result<ListProgressUpdateStreamsResult, RusotoError<ListProgressUpdateStreamsError>>;
async fn notify_application_state(
&self,
input: NotifyApplicationStateRequest,
) -> Result<NotifyApplicationStateResult, RusotoError<NotifyApplicationStateError>>;
async fn notify_migration_task_state(
&self,
input: NotifyMigrationTaskStateRequest,
) -> Result<NotifyMigrationTaskStateResult, RusotoError<NotifyMigrationTaskStateError>>;
async fn put_resource_attributes(
&self,
input: PutResourceAttributesRequest,
) -> Result<PutResourceAttributesResult, RusotoError<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,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> MigrationHubClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
MigrationHubClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> MigrationHubClient {
MigrationHubClient { client, region }
}
}
#[async_trait]
impl MigrationHub for MigrationHubClient {
async fn associate_created_artifact(
&self,
input: AssociateCreatedArtifactRequest,
) -> Result<AssociateCreatedArtifactResult, RusotoError<AssociateCreatedArtifactError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.AssociateCreatedArtifact");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AssociateCreatedArtifactError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateCreatedArtifactResult, _>()
}
async fn associate_discovered_resource(
&self,
input: AssociateDiscoveredResourceRequest,
) -> Result<AssociateDiscoveredResourceResult, RusotoError<AssociateDiscoveredResourceError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSMigrationHub.AssociateDiscoveredResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AssociateDiscoveredResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateDiscoveredResourceResult, _>()
}
async fn create_progress_update_stream(
&self,
input: CreateProgressUpdateStreamRequest,
) -> Result<CreateProgressUpdateStreamResult, RusotoError<CreateProgressUpdateStreamError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.CreateProgressUpdateStream");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateProgressUpdateStreamError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateProgressUpdateStreamResult, _>()
}
async fn delete_progress_update_stream(
&self,
input: DeleteProgressUpdateStreamRequest,
) -> Result<DeleteProgressUpdateStreamResult, RusotoError<DeleteProgressUpdateStreamError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.DeleteProgressUpdateStream");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteProgressUpdateStreamError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteProgressUpdateStreamResult, _>()
}
async fn describe_application_state(
&self,
input: DescribeApplicationStateRequest,
) -> Result<DescribeApplicationStateResult, RusotoError<DescribeApplicationStateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.DescribeApplicationState");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeApplicationStateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeApplicationStateResult, _>()
}
async fn describe_migration_task(
&self,
input: DescribeMigrationTaskRequest,
) -> Result<DescribeMigrationTaskResult, RusotoError<DescribeMigrationTaskError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.DescribeMigrationTask");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeMigrationTaskError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeMigrationTaskResult, _>()
}
async fn disassociate_created_artifact(
&self,
input: DisassociateCreatedArtifactRequest,
) -> Result<DisassociateCreatedArtifactResult, RusotoError<DisassociateCreatedArtifactError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSMigrationHub.DisassociateCreatedArtifact",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DisassociateCreatedArtifactError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateCreatedArtifactResult, _>()
}
async fn disassociate_discovered_resource(
&self,
input: DisassociateDiscoveredResourceRequest,
) -> Result<
DisassociateDiscoveredResourceResult,
RusotoError<DisassociateDiscoveredResourceError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSMigrationHub.DisassociateDiscoveredResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DisassociateDiscoveredResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateDiscoveredResourceResult, _>()
}
async fn import_migration_task(
&self,
input: ImportMigrationTaskRequest,
) -> Result<ImportMigrationTaskResult, RusotoError<ImportMigrationTaskError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.ImportMigrationTask");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ImportMigrationTaskError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ImportMigrationTaskResult, _>()
}
async fn list_application_states(
&self,
input: ListApplicationStatesRequest,
) -> Result<ListApplicationStatesResult, RusotoError<ListApplicationStatesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.ListApplicationStates");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListApplicationStatesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListApplicationStatesResult, _>()
}
async fn list_created_artifacts(
&self,
input: ListCreatedArtifactsRequest,
) -> Result<ListCreatedArtifactsResult, RusotoError<ListCreatedArtifactsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.ListCreatedArtifacts");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListCreatedArtifactsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListCreatedArtifactsResult, _>()
}
async fn list_discovered_resources(
&self,
input: ListDiscoveredResourcesRequest,
) -> Result<ListDiscoveredResourcesResult, RusotoError<ListDiscoveredResourcesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.ListDiscoveredResources");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDiscoveredResourcesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListDiscoveredResourcesResult, _>()
}
async fn list_migration_tasks(
&self,
input: ListMigrationTasksRequest,
) -> Result<ListMigrationTasksResult, RusotoError<ListMigrationTasksError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.ListMigrationTasks");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListMigrationTasksError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListMigrationTasksResult, _>()
}
async fn list_progress_update_streams(
&self,
input: ListProgressUpdateStreamsRequest,
) -> Result<ListProgressUpdateStreamsResult, RusotoError<ListProgressUpdateStreamsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.ListProgressUpdateStreams");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListProgressUpdateStreamsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListProgressUpdateStreamsResult, _>()
}
async fn notify_application_state(
&self,
input: NotifyApplicationStateRequest,
) -> Result<NotifyApplicationStateResult, RusotoError<NotifyApplicationStateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.NotifyApplicationState");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, NotifyApplicationStateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<NotifyApplicationStateResult, _>()
}
async fn notify_migration_task_state(
&self,
input: NotifyMigrationTaskStateRequest,
) -> Result<NotifyMigrationTaskStateResult, RusotoError<NotifyMigrationTaskStateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.NotifyMigrationTaskState");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, NotifyMigrationTaskStateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<NotifyMigrationTaskStateResult, _>()
}
async fn put_resource_attributes(
&self,
input: PutResourceAttributesRequest,
) -> Result<PutResourceAttributesResult, RusotoError<PutResourceAttributesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSMigrationHub.PutResourceAttributes");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutResourceAttributesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<PutResourceAttributesResult, _>()
}
}