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 ServerMigrationServiceClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "sms", &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 AppSummary {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "lastModified")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified: Option<f64>,
#[serde(rename = "latestReplicationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_replication_time: Option<f64>,
#[serde(rename = "launchDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub launch_details: Option<LaunchDetails>,
#[serde(rename = "launchStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub launch_status: Option<String>,
#[serde(rename = "launchStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub launch_status_message: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "replicationStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_status: Option<String>,
#[serde(rename = "replicationStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_status_message: Option<String>,
#[serde(rename = "roleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "statusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(rename = "totalServerGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_server_groups: Option<i64>,
#[serde(rename = "totalServers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_servers: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Connector {
#[serde(rename = "associatedOn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_on: Option<f64>,
#[serde(rename = "capabilityList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub capability_list: Option<Vec<String>>,
#[serde(rename = "connectorId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_id: Option<String>,
#[serde(rename = "ipAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address: Option<String>,
#[serde(rename = "macAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mac_address: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(rename = "vmManagerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vm_manager_id: Option<String>,
#[serde(rename = "vmManagerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vm_manager_name: Option<String>,
#[serde(rename = "vmManagerType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vm_manager_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateAppRequest {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "roleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_name: Option<String>,
#[serde(rename = "serverGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_groups: Option<Vec<ServerGroup>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateAppResponse {
#[serde(rename = "appSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_summary: Option<AppSummary>,
#[serde(rename = "serverGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_groups: Option<Vec<ServerGroup>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateReplicationJobRequest {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "encrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encrypted: Option<bool>,
#[serde(rename = "frequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub frequency: Option<i64>,
#[serde(rename = "kmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "licenseType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_type: Option<String>,
#[serde(rename = "numberOfRecentAmisToKeep")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_recent_amis_to_keep: Option<i64>,
#[serde(rename = "roleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_name: Option<String>,
#[serde(rename = "runOnce")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run_once: Option<bool>,
#[serde(rename = "seedReplicationTime")]
pub seed_replication_time: f64,
#[serde(rename = "serverId")]
pub server_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateReplicationJobResponse {
#[serde(rename = "replicationJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_job_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAppLaunchConfigurationRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteAppLaunchConfigurationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAppReplicationConfigurationRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteAppReplicationConfigurationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAppRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
#[serde(rename = "forceStopAppReplication")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force_stop_app_replication: Option<bool>,
#[serde(rename = "forceTerminateApp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force_terminate_app: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteAppResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteReplicationJobRequest {
#[serde(rename = "replicationJobId")]
pub replication_job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteReplicationJobResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteServerCatalogRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteServerCatalogResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateConnectorRequest {
#[serde(rename = "connectorId")]
pub connector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateConnectorResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GenerateChangeSetRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
#[serde(rename = "changesetFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub changeset_format: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GenerateChangeSetResponse {
#[serde(rename = "s3Location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_location: Option<S3Location>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GenerateTemplateRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
#[serde(rename = "templateFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_format: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GenerateTemplateResponse {
#[serde(rename = "s3Location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_location: Option<S3Location>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAppLaunchConfigurationRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAppLaunchConfigurationResponse {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
#[serde(rename = "roleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_name: Option<String>,
#[serde(rename = "serverGroupLaunchConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_group_launch_configurations: Option<Vec<ServerGroupLaunchConfiguration>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAppReplicationConfigurationRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAppReplicationConfigurationResponse {
#[serde(rename = "serverGroupReplicationConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_group_replication_configurations: Option<Vec<ServerGroupReplicationConfiguration>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAppRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAppResponse {
#[serde(rename = "appSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_summary: Option<AppSummary>,
#[serde(rename = "serverGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_groups: Option<Vec<ServerGroup>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetConnectorsRequest {
#[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 GetConnectorsResponse {
#[serde(rename = "connectorList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_list: Option<Vec<Connector>>,
#[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 GetReplicationJobsRequest {
#[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 = "replicationJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_job_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetReplicationJobsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "replicationJobList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_job_list: Option<Vec<ReplicationJob>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetReplicationRunsRequest {
#[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 = "replicationJobId")]
pub replication_job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetReplicationRunsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "replicationJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_job: Option<ReplicationJob>,
#[serde(rename = "replicationRunList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_run_list: Option<Vec<ReplicationRun>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetServersRequest {
#[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 = "vmServerAddressList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vm_server_address_list: Option<Vec<VmServerAddress>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetServersResponse {
#[serde(rename = "lastModifiedOn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_on: Option<f64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "serverCatalogStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_catalog_status: Option<String>,
#[serde(rename = "serverList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_list: Option<Vec<Server>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ImportServerCatalogRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImportServerCatalogResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct LaunchAppRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LaunchAppResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LaunchDetails {
#[serde(rename = "latestLaunchTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_launch_time: Option<f64>,
#[serde(rename = "stackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
#[serde(rename = "stackName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAppsRequest {
#[serde(rename = "appIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_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 ListAppsResponse {
#[serde(rename = "apps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub apps: Option<Vec<AppSummary>>,
#[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 PutAppLaunchConfigurationRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
#[serde(rename = "roleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_name: Option<String>,
#[serde(rename = "serverGroupLaunchConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_group_launch_configurations: Option<Vec<ServerGroupLaunchConfiguration>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutAppLaunchConfigurationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutAppReplicationConfigurationRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
#[serde(rename = "serverGroupReplicationConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_group_replication_configurations: Option<Vec<ServerGroupReplicationConfiguration>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutAppReplicationConfigurationResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReplicationJob {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "encrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encrypted: Option<bool>,
#[serde(rename = "frequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub frequency: Option<i64>,
#[serde(rename = "kmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "latestAmiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_ami_id: Option<String>,
#[serde(rename = "licenseType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_type: Option<String>,
#[serde(rename = "nextReplicationRunStartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_replication_run_start_time: Option<f64>,
#[serde(rename = "numberOfRecentAmisToKeep")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_recent_amis_to_keep: Option<i64>,
#[serde(rename = "replicationJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_job_id: Option<String>,
#[serde(rename = "replicationRunList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_run_list: Option<Vec<ReplicationRun>>,
#[serde(rename = "roleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_name: Option<String>,
#[serde(rename = "runOnce")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run_once: Option<bool>,
#[serde(rename = "seedReplicationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub seed_replication_time: Option<f64>,
#[serde(rename = "serverId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_id: Option<String>,
#[serde(rename = "serverType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_type: Option<String>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "statusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(rename = "vmServer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vm_server: Option<VmServer>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReplicationRun {
#[serde(rename = "amiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ami_id: Option<String>,
#[serde(rename = "completedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completed_time: Option<f64>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "encrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encrypted: Option<bool>,
#[serde(rename = "kmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "replicationRunId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_run_id: Option<String>,
#[serde(rename = "scheduledStartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scheduled_start_time: Option<f64>,
#[serde(rename = "stageDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_details: Option<ReplicationRunStageDetails>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "statusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReplicationRunStageDetails {
#[serde(rename = "stage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage: Option<String>,
#[serde(rename = "stageProgress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_progress: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct S3Location {
#[serde(rename = "bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket: Option<String>,
#[serde(rename = "key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Server {
#[serde(rename = "replicationJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_job_id: Option<String>,
#[serde(rename = "replicationJobTerminated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_job_terminated: Option<bool>,
#[serde(rename = "serverId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_id: Option<String>,
#[serde(rename = "serverType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_type: Option<String>,
#[serde(rename = "vmServer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vm_server: Option<VmServer>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ServerGroup {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "serverGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_group_id: Option<String>,
#[serde(rename = "serverList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_list: Option<Vec<Server>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ServerGroupLaunchConfiguration {
#[serde(rename = "launchOrder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub launch_order: Option<i64>,
#[serde(rename = "serverGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_group_id: Option<String>,
#[serde(rename = "serverLaunchConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_launch_configurations: Option<Vec<ServerLaunchConfiguration>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ServerGroupReplicationConfiguration {
#[serde(rename = "serverGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_group_id: Option<String>,
#[serde(rename = "serverReplicationConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_replication_configurations: Option<Vec<ServerReplicationConfiguration>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ServerLaunchConfiguration {
#[serde(rename = "associatePublicIpAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associate_public_ip_address: Option<bool>,
#[serde(rename = "ec2KeyName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_key_name: Option<String>,
#[serde(rename = "instanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type: Option<String>,
#[serde(rename = "logicalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logical_id: Option<String>,
#[serde(rename = "securityGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group: Option<String>,
#[serde(rename = "server")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server: Option<Server>,
#[serde(rename = "subnet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet: Option<String>,
#[serde(rename = "userData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_data: Option<UserData>,
#[serde(rename = "vpc")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ServerReplicationConfiguration {
#[serde(rename = "server")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server: Option<Server>,
#[serde(rename = "serverReplicationParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_replication_parameters: Option<ServerReplicationParameters>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ServerReplicationParameters {
#[serde(rename = "encrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encrypted: Option<bool>,
#[serde(rename = "frequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub frequency: Option<i64>,
#[serde(rename = "kmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "licenseType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_type: Option<String>,
#[serde(rename = "numberOfRecentAmisToKeep")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_recent_amis_to_keep: Option<i64>,
#[serde(rename = "runOnce")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run_once: Option<bool>,
#[serde(rename = "seedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub seed_time: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartAppReplicationRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartAppReplicationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartOnDemandReplicationRunRequest {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "replicationJobId")]
pub replication_job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartOnDemandReplicationRunResponse {
#[serde(rename = "replicationRunId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_run_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopAppReplicationRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopAppReplicationResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TerminateAppRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TerminateAppResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateAppRequest {
#[serde(rename = "appId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "roleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_name: Option<String>,
#[serde(rename = "serverGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_groups: Option<Vec<ServerGroup>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateAppResponse {
#[serde(rename = "appSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_summary: Option<AppSummary>,
#[serde(rename = "serverGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_groups: Option<Vec<ServerGroup>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateReplicationJobRequest {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "encrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encrypted: Option<bool>,
#[serde(rename = "frequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub frequency: Option<i64>,
#[serde(rename = "kmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "licenseType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_type: Option<String>,
#[serde(rename = "nextReplicationRunStartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_replication_run_start_time: Option<f64>,
#[serde(rename = "numberOfRecentAmisToKeep")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_recent_amis_to_keep: Option<i64>,
#[serde(rename = "replicationJobId")]
pub replication_job_id: String,
#[serde(rename = "roleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateReplicationJobResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct UserData {
#[serde(rename = "s3Location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_location: Option<S3Location>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct VmServer {
#[serde(rename = "vmManagerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vm_manager_name: Option<String>,
#[serde(rename = "vmManagerType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vm_manager_type: Option<String>,
#[serde(rename = "vmName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vm_name: Option<String>,
#[serde(rename = "vmPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vm_path: Option<String>,
#[serde(rename = "vmServerAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vm_server_address: Option<VmServerAddress>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct VmServerAddress {
#[serde(rename = "vmId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vm_id: Option<String>,
#[serde(rename = "vmManagerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vm_manager_id: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum CreateAppError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl CreateAppError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateAppError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(CreateAppError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateAppError::InvalidParameter(err.msg))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(CreateAppError::MissingRequiredParameter(err.msg))
}
"OperationNotPermittedException" => {
return RusotoError::Service(CreateAppError::OperationNotPermitted(err.msg))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(CreateAppError::UnauthorizedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateAppError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateAppError::InternalError(ref cause) => write!(f, "{}", cause),
CreateAppError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateAppError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
CreateAppError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
CreateAppError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateAppError {}
#[derive(Debug, PartialEq)]
pub enum CreateReplicationJobError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
NoConnectorsAvailable(String),
OperationNotPermitted(String),
ReplicationJobAlreadyExists(String),
ServerCannotBeReplicated(String),
TemporarilyUnavailable(String),
UnauthorizedOperation(String),
}
impl CreateReplicationJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateReplicationJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(CreateReplicationJobError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateReplicationJobError::InvalidParameter(
err.msg,
))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
CreateReplicationJobError::MissingRequiredParameter(err.msg),
)
}
"NoConnectorsAvailableException" => {
return RusotoError::Service(CreateReplicationJobError::NoConnectorsAvailable(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(CreateReplicationJobError::OperationNotPermitted(
err.msg,
))
}
"ReplicationJobAlreadyExistsException" => {
return RusotoError::Service(
CreateReplicationJobError::ReplicationJobAlreadyExists(err.msg),
)
}
"ServerCannotBeReplicatedException" => {
return RusotoError::Service(
CreateReplicationJobError::ServerCannotBeReplicated(err.msg),
)
}
"TemporarilyUnavailableException" => {
return RusotoError::Service(CreateReplicationJobError::TemporarilyUnavailable(
err.msg,
))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(CreateReplicationJobError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateReplicationJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateReplicationJobError::InternalError(ref cause) => write!(f, "{}", cause),
CreateReplicationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateReplicationJobError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationJobError::NoConnectorsAvailable(ref cause) => write!(f, "{}", cause),
CreateReplicationJobError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
CreateReplicationJobError::ReplicationJobAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationJobError::ServerCannotBeReplicated(ref cause) => {
write!(f, "{}", cause)
}
CreateReplicationJobError::TemporarilyUnavailable(ref cause) => write!(f, "{}", cause),
CreateReplicationJobError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateReplicationJobError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAppError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl DeleteAppError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAppError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(DeleteAppError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteAppError::InvalidParameter(err.msg))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(DeleteAppError::MissingRequiredParameter(err.msg))
}
"OperationNotPermittedException" => {
return RusotoError::Service(DeleteAppError::OperationNotPermitted(err.msg))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(DeleteAppError::UnauthorizedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAppError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAppError::InternalError(ref cause) => write!(f, "{}", cause),
DeleteAppError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteAppError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
DeleteAppError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
DeleteAppError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteAppError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAppLaunchConfigurationError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl DeleteAppLaunchConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteAppLaunchConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(DeleteAppLaunchConfigurationError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(
DeleteAppLaunchConfigurationError::InvalidParameter(err.msg),
)
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
DeleteAppLaunchConfigurationError::MissingRequiredParameter(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(
DeleteAppLaunchConfigurationError::OperationNotPermitted(err.msg),
)
}
"UnauthorizedOperationException" => {
return RusotoError::Service(
DeleteAppLaunchConfigurationError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAppLaunchConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAppLaunchConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
DeleteAppLaunchConfigurationError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
DeleteAppLaunchConfigurationError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
DeleteAppLaunchConfigurationError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
DeleteAppLaunchConfigurationError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteAppLaunchConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAppReplicationConfigurationError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl DeleteAppReplicationConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteAppReplicationConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(
DeleteAppReplicationConfigurationError::InternalError(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
DeleteAppReplicationConfigurationError::InvalidParameter(err.msg),
)
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
DeleteAppReplicationConfigurationError::MissingRequiredParameter(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(
DeleteAppReplicationConfigurationError::OperationNotPermitted(err.msg),
)
}
"UnauthorizedOperationException" => {
return RusotoError::Service(
DeleteAppReplicationConfigurationError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAppReplicationConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAppReplicationConfigurationError::InternalError(ref cause) => {
write!(f, "{}", cause)
}
DeleteAppReplicationConfigurationError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
DeleteAppReplicationConfigurationError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
DeleteAppReplicationConfigurationError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
DeleteAppReplicationConfigurationError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteAppReplicationConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteReplicationJobError {
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
ReplicationJobNotFound(String),
UnauthorizedOperation(String),
}
impl DeleteReplicationJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteReplicationJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterException" => {
return RusotoError::Service(DeleteReplicationJobError::InvalidParameter(
err.msg,
))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
DeleteReplicationJobError::MissingRequiredParameter(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(DeleteReplicationJobError::OperationNotPermitted(
err.msg,
))
}
"ReplicationJobNotFoundException" => {
return RusotoError::Service(DeleteReplicationJobError::ReplicationJobNotFound(
err.msg,
))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(DeleteReplicationJobError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteReplicationJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteReplicationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteReplicationJobError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
DeleteReplicationJobError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
DeleteReplicationJobError::ReplicationJobNotFound(ref cause) => write!(f, "{}", cause),
DeleteReplicationJobError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteReplicationJobError {}
#[derive(Debug, PartialEq)]
pub enum DeleteServerCatalogError {
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl DeleteServerCatalogError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteServerCatalogError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterException" => {
return RusotoError::Service(DeleteServerCatalogError::InvalidParameter(
err.msg,
))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
DeleteServerCatalogError::MissingRequiredParameter(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(DeleteServerCatalogError::OperationNotPermitted(
err.msg,
))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(DeleteServerCatalogError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteServerCatalogError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteServerCatalogError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteServerCatalogError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
DeleteServerCatalogError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
DeleteServerCatalogError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteServerCatalogError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateConnectorError {
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl DisassociateConnectorError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisassociateConnectorError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterException" => {
return RusotoError::Service(DisassociateConnectorError::InvalidParameter(
err.msg,
))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
DisassociateConnectorError::MissingRequiredParameter(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(DisassociateConnectorError::OperationNotPermitted(
err.msg,
))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(DisassociateConnectorError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateConnectorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateConnectorError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DisassociateConnectorError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
DisassociateConnectorError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
DisassociateConnectorError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisassociateConnectorError {}
#[derive(Debug, PartialEq)]
pub enum GenerateChangeSetError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl GenerateChangeSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GenerateChangeSetError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(GenerateChangeSetError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GenerateChangeSetError::InvalidParameter(err.msg))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(GenerateChangeSetError::MissingRequiredParameter(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(GenerateChangeSetError::OperationNotPermitted(
err.msg,
))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(GenerateChangeSetError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GenerateChangeSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GenerateChangeSetError::InternalError(ref cause) => write!(f, "{}", cause),
GenerateChangeSetError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GenerateChangeSetError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
GenerateChangeSetError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
GenerateChangeSetError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GenerateChangeSetError {}
#[derive(Debug, PartialEq)]
pub enum GenerateTemplateError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl GenerateTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GenerateTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(GenerateTemplateError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GenerateTemplateError::InvalidParameter(err.msg))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(GenerateTemplateError::MissingRequiredParameter(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(GenerateTemplateError::OperationNotPermitted(
err.msg,
))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(GenerateTemplateError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GenerateTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GenerateTemplateError::InternalError(ref cause) => write!(f, "{}", cause),
GenerateTemplateError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GenerateTemplateError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
GenerateTemplateError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
GenerateTemplateError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GenerateTemplateError {}
#[derive(Debug, PartialEq)]
pub enum GetAppError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl GetAppError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAppError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(GetAppError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetAppError::InvalidParameter(err.msg))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(GetAppError::MissingRequiredParameter(err.msg))
}
"OperationNotPermittedException" => {
return RusotoError::Service(GetAppError::OperationNotPermitted(err.msg))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(GetAppError::UnauthorizedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAppError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAppError::InternalError(ref cause) => write!(f, "{}", cause),
GetAppError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetAppError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
GetAppError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
GetAppError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAppError {}
#[derive(Debug, PartialEq)]
pub enum GetAppLaunchConfigurationError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl GetAppLaunchConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAppLaunchConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(GetAppLaunchConfigurationError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(GetAppLaunchConfigurationError::InvalidParameter(
err.msg,
))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
GetAppLaunchConfigurationError::MissingRequiredParameter(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(
GetAppLaunchConfigurationError::OperationNotPermitted(err.msg),
)
}
"UnauthorizedOperationException" => {
return RusotoError::Service(
GetAppLaunchConfigurationError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAppLaunchConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAppLaunchConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
GetAppLaunchConfigurationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetAppLaunchConfigurationError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
GetAppLaunchConfigurationError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
GetAppLaunchConfigurationError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetAppLaunchConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum GetAppReplicationConfigurationError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl GetAppReplicationConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetAppReplicationConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(
GetAppReplicationConfigurationError::InternalError(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
GetAppReplicationConfigurationError::InvalidParameter(err.msg),
)
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
GetAppReplicationConfigurationError::MissingRequiredParameter(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(
GetAppReplicationConfigurationError::OperationNotPermitted(err.msg),
)
}
"UnauthorizedOperationException" => {
return RusotoError::Service(
GetAppReplicationConfigurationError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAppReplicationConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAppReplicationConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
GetAppReplicationConfigurationError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
GetAppReplicationConfigurationError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
GetAppReplicationConfigurationError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
GetAppReplicationConfigurationError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetAppReplicationConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum GetConnectorsError {
UnauthorizedOperation(String),
}
impl GetConnectorsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetConnectorsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"UnauthorizedOperationException" => {
return RusotoError::Service(GetConnectorsError::UnauthorizedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetConnectorsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetConnectorsError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetConnectorsError {}
#[derive(Debug, PartialEq)]
pub enum GetReplicationJobsError {
InvalidParameter(String),
MissingRequiredParameter(String),
UnauthorizedOperation(String),
}
impl GetReplicationJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetReplicationJobsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterException" => {
return RusotoError::Service(GetReplicationJobsError::InvalidParameter(err.msg))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(GetReplicationJobsError::MissingRequiredParameter(
err.msg,
))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(GetReplicationJobsError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetReplicationJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetReplicationJobsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetReplicationJobsError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
GetReplicationJobsError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetReplicationJobsError {}
#[derive(Debug, PartialEq)]
pub enum GetReplicationRunsError {
InvalidParameter(String),
MissingRequiredParameter(String),
UnauthorizedOperation(String),
}
impl GetReplicationRunsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetReplicationRunsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterException" => {
return RusotoError::Service(GetReplicationRunsError::InvalidParameter(err.msg))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(GetReplicationRunsError::MissingRequiredParameter(
err.msg,
))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(GetReplicationRunsError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetReplicationRunsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetReplicationRunsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetReplicationRunsError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
GetReplicationRunsError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetReplicationRunsError {}
#[derive(Debug, PartialEq)]
pub enum GetServersError {
UnauthorizedOperation(String),
}
impl GetServersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetServersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"UnauthorizedOperationException" => {
return RusotoError::Service(GetServersError::UnauthorizedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetServersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetServersError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetServersError {}
#[derive(Debug, PartialEq)]
pub enum ImportServerCatalogError {
InvalidParameter(String),
MissingRequiredParameter(String),
NoConnectorsAvailable(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl ImportServerCatalogError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ImportServerCatalogError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterException" => {
return RusotoError::Service(ImportServerCatalogError::InvalidParameter(
err.msg,
))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
ImportServerCatalogError::MissingRequiredParameter(err.msg),
)
}
"NoConnectorsAvailableException" => {
return RusotoError::Service(ImportServerCatalogError::NoConnectorsAvailable(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(ImportServerCatalogError::OperationNotPermitted(
err.msg,
))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(ImportServerCatalogError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ImportServerCatalogError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ImportServerCatalogError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ImportServerCatalogError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
ImportServerCatalogError::NoConnectorsAvailable(ref cause) => write!(f, "{}", cause),
ImportServerCatalogError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
ImportServerCatalogError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ImportServerCatalogError {}
#[derive(Debug, PartialEq)]
pub enum LaunchAppError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl LaunchAppError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<LaunchAppError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(LaunchAppError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(LaunchAppError::InvalidParameter(err.msg))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(LaunchAppError::MissingRequiredParameter(err.msg))
}
"OperationNotPermittedException" => {
return RusotoError::Service(LaunchAppError::OperationNotPermitted(err.msg))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(LaunchAppError::UnauthorizedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for LaunchAppError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
LaunchAppError::InternalError(ref cause) => write!(f, "{}", cause),
LaunchAppError::InvalidParameter(ref cause) => write!(f, "{}", cause),
LaunchAppError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
LaunchAppError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
LaunchAppError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for LaunchAppError {}
#[derive(Debug, PartialEq)]
pub enum ListAppsError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl ListAppsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAppsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(ListAppsError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListAppsError::InvalidParameter(err.msg))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(ListAppsError::MissingRequiredParameter(err.msg))
}
"OperationNotPermittedException" => {
return RusotoError::Service(ListAppsError::OperationNotPermitted(err.msg))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(ListAppsError::UnauthorizedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAppsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAppsError::InternalError(ref cause) => write!(f, "{}", cause),
ListAppsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListAppsError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
ListAppsError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
ListAppsError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListAppsError {}
#[derive(Debug, PartialEq)]
pub enum PutAppLaunchConfigurationError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl PutAppLaunchConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutAppLaunchConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(PutAppLaunchConfigurationError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(PutAppLaunchConfigurationError::InvalidParameter(
err.msg,
))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
PutAppLaunchConfigurationError::MissingRequiredParameter(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(
PutAppLaunchConfigurationError::OperationNotPermitted(err.msg),
)
}
"UnauthorizedOperationException" => {
return RusotoError::Service(
PutAppLaunchConfigurationError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutAppLaunchConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutAppLaunchConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
PutAppLaunchConfigurationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
PutAppLaunchConfigurationError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
PutAppLaunchConfigurationError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
PutAppLaunchConfigurationError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutAppLaunchConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum PutAppReplicationConfigurationError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl PutAppReplicationConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutAppReplicationConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(
PutAppReplicationConfigurationError::InternalError(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
PutAppReplicationConfigurationError::InvalidParameter(err.msg),
)
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
PutAppReplicationConfigurationError::MissingRequiredParameter(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(
PutAppReplicationConfigurationError::OperationNotPermitted(err.msg),
)
}
"UnauthorizedOperationException" => {
return RusotoError::Service(
PutAppReplicationConfigurationError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutAppReplicationConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutAppReplicationConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
PutAppReplicationConfigurationError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
PutAppReplicationConfigurationError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
PutAppReplicationConfigurationError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
PutAppReplicationConfigurationError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutAppReplicationConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum StartAppReplicationError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl StartAppReplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartAppReplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(StartAppReplicationError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(StartAppReplicationError::InvalidParameter(
err.msg,
))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
StartAppReplicationError::MissingRequiredParameter(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(StartAppReplicationError::OperationNotPermitted(
err.msg,
))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(StartAppReplicationError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartAppReplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartAppReplicationError::InternalError(ref cause) => write!(f, "{}", cause),
StartAppReplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StartAppReplicationError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
StartAppReplicationError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
StartAppReplicationError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartAppReplicationError {}
#[derive(Debug, PartialEq)]
pub enum StartOnDemandReplicationRunError {
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
ReplicationRunLimitExceeded(String),
UnauthorizedOperation(String),
}
impl StartOnDemandReplicationRunError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<StartOnDemandReplicationRunError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterException" => {
return RusotoError::Service(
StartOnDemandReplicationRunError::InvalidParameter(err.msg),
)
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
StartOnDemandReplicationRunError::MissingRequiredParameter(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(
StartOnDemandReplicationRunError::OperationNotPermitted(err.msg),
)
}
"ReplicationRunLimitExceededException" => {
return RusotoError::Service(
StartOnDemandReplicationRunError::ReplicationRunLimitExceeded(err.msg),
)
}
"UnauthorizedOperationException" => {
return RusotoError::Service(
StartOnDemandReplicationRunError::UnauthorizedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartOnDemandReplicationRunError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartOnDemandReplicationRunError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StartOnDemandReplicationRunError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
StartOnDemandReplicationRunError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
StartOnDemandReplicationRunError::ReplicationRunLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
StartOnDemandReplicationRunError::UnauthorizedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for StartOnDemandReplicationRunError {}
#[derive(Debug, PartialEq)]
pub enum StopAppReplicationError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl StopAppReplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopAppReplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(StopAppReplicationError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(StopAppReplicationError::InvalidParameter(err.msg))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(StopAppReplicationError::MissingRequiredParameter(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(StopAppReplicationError::OperationNotPermitted(
err.msg,
))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(StopAppReplicationError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopAppReplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopAppReplicationError::InternalError(ref cause) => write!(f, "{}", cause),
StopAppReplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StopAppReplicationError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
StopAppReplicationError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
StopAppReplicationError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopAppReplicationError {}
#[derive(Debug, PartialEq)]
pub enum TerminateAppError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl TerminateAppError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TerminateAppError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(TerminateAppError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(TerminateAppError::InvalidParameter(err.msg))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(TerminateAppError::MissingRequiredParameter(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(TerminateAppError::OperationNotPermitted(err.msg))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(TerminateAppError::UnauthorizedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TerminateAppError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TerminateAppError::InternalError(ref cause) => write!(f, "{}", cause),
TerminateAppError::InvalidParameter(ref cause) => write!(f, "{}", cause),
TerminateAppError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
TerminateAppError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
TerminateAppError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TerminateAppError {}
#[derive(Debug, PartialEq)]
pub enum UpdateAppError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
UnauthorizedOperation(String),
}
impl UpdateAppError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateAppError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(UpdateAppError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateAppError::InvalidParameter(err.msg))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(UpdateAppError::MissingRequiredParameter(err.msg))
}
"OperationNotPermittedException" => {
return RusotoError::Service(UpdateAppError::OperationNotPermitted(err.msg))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(UpdateAppError::UnauthorizedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateAppError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateAppError::InternalError(ref cause) => write!(f, "{}", cause),
UpdateAppError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateAppError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
UpdateAppError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
UpdateAppError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateAppError {}
#[derive(Debug, PartialEq)]
pub enum UpdateReplicationJobError {
InternalError(String),
InvalidParameter(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
ReplicationJobNotFound(String),
ServerCannotBeReplicated(String),
TemporarilyUnavailable(String),
UnauthorizedOperation(String),
}
impl UpdateReplicationJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateReplicationJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalError" => {
return RusotoError::Service(UpdateReplicationJobError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateReplicationJobError::InvalidParameter(
err.msg,
))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
UpdateReplicationJobError::MissingRequiredParameter(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(UpdateReplicationJobError::OperationNotPermitted(
err.msg,
))
}
"ReplicationJobNotFoundException" => {
return RusotoError::Service(UpdateReplicationJobError::ReplicationJobNotFound(
err.msg,
))
}
"ServerCannotBeReplicatedException" => {
return RusotoError::Service(
UpdateReplicationJobError::ServerCannotBeReplicated(err.msg),
)
}
"TemporarilyUnavailableException" => {
return RusotoError::Service(UpdateReplicationJobError::TemporarilyUnavailable(
err.msg,
))
}
"UnauthorizedOperationException" => {
return RusotoError::Service(UpdateReplicationJobError::UnauthorizedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateReplicationJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateReplicationJobError::InternalError(ref cause) => write!(f, "{}", cause),
UpdateReplicationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateReplicationJobError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
UpdateReplicationJobError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
UpdateReplicationJobError::ReplicationJobNotFound(ref cause) => write!(f, "{}", cause),
UpdateReplicationJobError::ServerCannotBeReplicated(ref cause) => {
write!(f, "{}", cause)
}
UpdateReplicationJobError::TemporarilyUnavailable(ref cause) => write!(f, "{}", cause),
UpdateReplicationJobError::UnauthorizedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateReplicationJobError {}
#[async_trait]
pub trait ServerMigrationService {
async fn create_app(
&self,
input: CreateAppRequest,
) -> Result<CreateAppResponse, RusotoError<CreateAppError>>;
async fn create_replication_job(
&self,
input: CreateReplicationJobRequest,
) -> Result<CreateReplicationJobResponse, RusotoError<CreateReplicationJobError>>;
async fn delete_app(
&self,
input: DeleteAppRequest,
) -> Result<DeleteAppResponse, RusotoError<DeleteAppError>>;
async fn delete_app_launch_configuration(
&self,
input: DeleteAppLaunchConfigurationRequest,
) -> Result<DeleteAppLaunchConfigurationResponse, RusotoError<DeleteAppLaunchConfigurationError>>;
async fn delete_app_replication_configuration(
&self,
input: DeleteAppReplicationConfigurationRequest,
) -> Result<
DeleteAppReplicationConfigurationResponse,
RusotoError<DeleteAppReplicationConfigurationError>,
>;
async fn delete_replication_job(
&self,
input: DeleteReplicationJobRequest,
) -> Result<DeleteReplicationJobResponse, RusotoError<DeleteReplicationJobError>>;
async fn delete_server_catalog(
&self,
) -> Result<DeleteServerCatalogResponse, RusotoError<DeleteServerCatalogError>>;
async fn disassociate_connector(
&self,
input: DisassociateConnectorRequest,
) -> Result<DisassociateConnectorResponse, RusotoError<DisassociateConnectorError>>;
async fn generate_change_set(
&self,
input: GenerateChangeSetRequest,
) -> Result<GenerateChangeSetResponse, RusotoError<GenerateChangeSetError>>;
async fn generate_template(
&self,
input: GenerateTemplateRequest,
) -> Result<GenerateTemplateResponse, RusotoError<GenerateTemplateError>>;
async fn get_app(
&self,
input: GetAppRequest,
) -> Result<GetAppResponse, RusotoError<GetAppError>>;
async fn get_app_launch_configuration(
&self,
input: GetAppLaunchConfigurationRequest,
) -> Result<GetAppLaunchConfigurationResponse, RusotoError<GetAppLaunchConfigurationError>>;
async fn get_app_replication_configuration(
&self,
input: GetAppReplicationConfigurationRequest,
) -> Result<
GetAppReplicationConfigurationResponse,
RusotoError<GetAppReplicationConfigurationError>,
>;
async fn get_connectors(
&self,
input: GetConnectorsRequest,
) -> Result<GetConnectorsResponse, RusotoError<GetConnectorsError>>;
async fn get_replication_jobs(
&self,
input: GetReplicationJobsRequest,
) -> Result<GetReplicationJobsResponse, RusotoError<GetReplicationJobsError>>;
async fn get_replication_runs(
&self,
input: GetReplicationRunsRequest,
) -> Result<GetReplicationRunsResponse, RusotoError<GetReplicationRunsError>>;
async fn get_servers(
&self,
input: GetServersRequest,
) -> Result<GetServersResponse, RusotoError<GetServersError>>;
async fn import_server_catalog(
&self,
) -> Result<ImportServerCatalogResponse, RusotoError<ImportServerCatalogError>>;
async fn launch_app(
&self,
input: LaunchAppRequest,
) -> Result<LaunchAppResponse, RusotoError<LaunchAppError>>;
async fn list_apps(
&self,
input: ListAppsRequest,
) -> Result<ListAppsResponse, RusotoError<ListAppsError>>;
async fn put_app_launch_configuration(
&self,
input: PutAppLaunchConfigurationRequest,
) -> Result<PutAppLaunchConfigurationResponse, RusotoError<PutAppLaunchConfigurationError>>;
async fn put_app_replication_configuration(
&self,
input: PutAppReplicationConfigurationRequest,
) -> Result<
PutAppReplicationConfigurationResponse,
RusotoError<PutAppReplicationConfigurationError>,
>;
async fn start_app_replication(
&self,
input: StartAppReplicationRequest,
) -> Result<StartAppReplicationResponse, RusotoError<StartAppReplicationError>>;
async fn start_on_demand_replication_run(
&self,
input: StartOnDemandReplicationRunRequest,
) -> Result<StartOnDemandReplicationRunResponse, RusotoError<StartOnDemandReplicationRunError>>;
async fn stop_app_replication(
&self,
input: StopAppReplicationRequest,
) -> Result<StopAppReplicationResponse, RusotoError<StopAppReplicationError>>;
async fn terminate_app(
&self,
input: TerminateAppRequest,
) -> Result<TerminateAppResponse, RusotoError<TerminateAppError>>;
async fn update_app(
&self,
input: UpdateAppRequest,
) -> Result<UpdateAppResponse, RusotoError<UpdateAppError>>;
async fn update_replication_job(
&self,
input: UpdateReplicationJobRequest,
) -> Result<UpdateReplicationJobResponse, RusotoError<UpdateReplicationJobError>>;
}
#[derive(Clone)]
pub struct ServerMigrationServiceClient {
client: Client,
region: region::Region,
}
impl ServerMigrationServiceClient {
pub fn new(region: region::Region) -> ServerMigrationServiceClient {
ServerMigrationServiceClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ServerMigrationServiceClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ServerMigrationServiceClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ServerMigrationServiceClient {
ServerMigrationServiceClient { client, region }
}
}
#[async_trait]
impl ServerMigrationService for ServerMigrationServiceClient {
async fn create_app(
&self,
input: CreateAppRequest,
) -> Result<CreateAppResponse, RusotoError<CreateAppError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.CreateApp",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateAppError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateAppResponse, _>()
}
async fn create_replication_job(
&self,
input: CreateReplicationJobRequest,
) -> Result<CreateReplicationJobResponse, RusotoError<CreateReplicationJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.CreateReplicationJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateReplicationJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateReplicationJobResponse, _>()
}
async fn delete_app(
&self,
input: DeleteAppRequest,
) -> Result<DeleteAppResponse, RusotoError<DeleteAppError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.DeleteApp",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteAppError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteAppResponse, _>()
}
async fn delete_app_launch_configuration(
&self,
input: DeleteAppLaunchConfigurationRequest,
) -> Result<DeleteAppLaunchConfigurationResponse, RusotoError<DeleteAppLaunchConfigurationError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.DeleteAppLaunchConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteAppLaunchConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteAppLaunchConfigurationResponse, _>()
}
async fn delete_app_replication_configuration(
&self,
input: DeleteAppReplicationConfigurationRequest,
) -> Result<
DeleteAppReplicationConfigurationResponse,
RusotoError<DeleteAppReplicationConfigurationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.DeleteAppReplicationConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DeleteAppReplicationConfigurationError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteAppReplicationConfigurationResponse, _>()
}
async fn delete_replication_job(
&self,
input: DeleteReplicationJobRequest,
) -> Result<DeleteReplicationJobResponse, RusotoError<DeleteReplicationJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.DeleteReplicationJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteReplicationJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteReplicationJobResponse, _>()
}
async fn delete_server_catalog(
&self,
) -> Result<DeleteServerCatalogResponse, RusotoError<DeleteServerCatalogError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.DeleteServerCatalog",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, DeleteServerCatalogError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteServerCatalogResponse, _>()
}
async fn disassociate_connector(
&self,
input: DisassociateConnectorRequest,
) -> Result<DisassociateConnectorResponse, RusotoError<DisassociateConnectorError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.DisassociateConnector",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DisassociateConnectorError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateConnectorResponse, _>()
}
async fn generate_change_set(
&self,
input: GenerateChangeSetRequest,
) -> Result<GenerateChangeSetResponse, RusotoError<GenerateChangeSetError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.GenerateChangeSet",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GenerateChangeSetError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GenerateChangeSetResponse, _>()
}
async fn generate_template(
&self,
input: GenerateTemplateRequest,
) -> Result<GenerateTemplateResponse, RusotoError<GenerateTemplateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.GenerateTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GenerateTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GenerateTemplateResponse, _>()
}
async fn get_app(
&self,
input: GetAppRequest,
) -> Result<GetAppResponse, RusotoError<GetAppError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.GetApp",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetAppError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetAppResponse, _>()
}
async fn get_app_launch_configuration(
&self,
input: GetAppLaunchConfigurationRequest,
) -> Result<GetAppLaunchConfigurationResponse, RusotoError<GetAppLaunchConfigurationError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.GetAppLaunchConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetAppLaunchConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetAppLaunchConfigurationResponse, _>()
}
async fn get_app_replication_configuration(
&self,
input: GetAppReplicationConfigurationRequest,
) -> Result<
GetAppReplicationConfigurationResponse,
RusotoError<GetAppReplicationConfigurationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.GetAppReplicationConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetAppReplicationConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetAppReplicationConfigurationResponse, _>()
}
async fn get_connectors(
&self,
input: GetConnectorsRequest,
) -> Result<GetConnectorsResponse, RusotoError<GetConnectorsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.GetConnectors",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetConnectorsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetConnectorsResponse, _>()
}
async fn get_replication_jobs(
&self,
input: GetReplicationJobsRequest,
) -> Result<GetReplicationJobsResponse, RusotoError<GetReplicationJobsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.GetReplicationJobs",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetReplicationJobsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetReplicationJobsResponse, _>()
}
async fn get_replication_runs(
&self,
input: GetReplicationRunsRequest,
) -> Result<GetReplicationRunsResponse, RusotoError<GetReplicationRunsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.GetReplicationRuns",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetReplicationRunsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetReplicationRunsResponse, _>()
}
async fn get_servers(
&self,
input: GetServersRequest,
) -> Result<GetServersResponse, RusotoError<GetServersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.GetServers",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetServersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetServersResponse, _>()
}
async fn import_server_catalog(
&self,
) -> Result<ImportServerCatalogResponse, RusotoError<ImportServerCatalogError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.ImportServerCatalog",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, ImportServerCatalogError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ImportServerCatalogResponse, _>()
}
async fn launch_app(
&self,
input: LaunchAppRequest,
) -> Result<LaunchAppResponse, RusotoError<LaunchAppError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.LaunchApp",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, LaunchAppError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<LaunchAppResponse, _>()
}
async fn list_apps(
&self,
input: ListAppsRequest,
) -> Result<ListAppsResponse, RusotoError<ListAppsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.ListApps",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListAppsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListAppsResponse, _>()
}
async fn put_app_launch_configuration(
&self,
input: PutAppLaunchConfigurationRequest,
) -> Result<PutAppLaunchConfigurationResponse, RusotoError<PutAppLaunchConfigurationError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.PutAppLaunchConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutAppLaunchConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutAppLaunchConfigurationResponse, _>()
}
async fn put_app_replication_configuration(
&self,
input: PutAppReplicationConfigurationRequest,
) -> Result<
PutAppReplicationConfigurationResponse,
RusotoError<PutAppReplicationConfigurationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.PutAppReplicationConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutAppReplicationConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutAppReplicationConfigurationResponse, _>()
}
async fn start_app_replication(
&self,
input: StartAppReplicationRequest,
) -> Result<StartAppReplicationResponse, RusotoError<StartAppReplicationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.StartAppReplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartAppReplicationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StartAppReplicationResponse, _>()
}
async fn start_on_demand_replication_run(
&self,
input: StartOnDemandReplicationRunRequest,
) -> Result<StartOnDemandReplicationRunResponse, RusotoError<StartOnDemandReplicationRunError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.StartOnDemandReplicationRun",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartOnDemandReplicationRunError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartOnDemandReplicationRunResponse, _>()
}
async fn stop_app_replication(
&self,
input: StopAppReplicationRequest,
) -> Result<StopAppReplicationResponse, RusotoError<StopAppReplicationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.StopAppReplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopAppReplicationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StopAppReplicationResponse, _>()
}
async fn terminate_app(
&self,
input: TerminateAppRequest,
) -> Result<TerminateAppResponse, RusotoError<TerminateAppError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.TerminateApp",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TerminateAppError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TerminateAppResponse, _>()
}
async fn update_app(
&self,
input: UpdateAppRequest,
) -> Result<UpdateAppResponse, RusotoError<UpdateAppError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.UpdateApp",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateAppError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateAppResponse, _>()
}
async fn update_replication_job(
&self,
input: UpdateReplicationJobRequest,
) -> Result<UpdateReplicationJobResponse, RusotoError<UpdateReplicationJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSServerMigrationService_V2016_10_24.UpdateReplicationJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateReplicationJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateReplicationJobResponse, _>()
}
}