use std::error::Error;
use std::fmt;
use std::io;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoFuture};
use rusoto_core::credential::{CredentialsError, ProvideAwsCredentials};
use rusoto_core::request::HttpDispatchError;
use rusoto_core::signature::SignedRequest;
use serde_json;
use serde_json::from_slice;
use serde_json::Value as SerdeJsonValue;
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Application {
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "IconURL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub icon_url: Option<String>,
#[serde(rename = "LaunchParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub launch_parameters: Option<String>,
#[serde(rename = "LaunchPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub launch_path: Option<String>,
#[serde(rename = "Metadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AssociateFleetRequest {
#[serde(rename = "FleetName")]
pub fleet_name: String,
#[serde(rename = "StackName")]
pub stack_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssociateFleetResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ComputeCapacity {
#[serde(rename = "DesiredInstances")]
pub desired_instances: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ComputeCapacityStatus {
#[serde(rename = "Available")]
#[serde(skip_serializing_if = "Option::is_none")]
pub available: Option<i64>,
#[serde(rename = "Desired")]
pub desired: i64,
#[serde(rename = "InUse")]
#[serde(skip_serializing_if = "Option::is_none")]
pub in_use: Option<i64>,
#[serde(rename = "Running")]
#[serde(skip_serializing_if = "Option::is_none")]
pub running: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CopyImageRequest {
#[serde(rename = "DestinationImageDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_image_description: Option<String>,
#[serde(rename = "DestinationImageName")]
pub destination_image_name: String,
#[serde(rename = "DestinationRegion")]
pub destination_region: String,
#[serde(rename = "SourceImageName")]
pub source_image_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CopyImageResponse {
#[serde(rename = "DestinationImageName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_image_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateDirectoryConfigRequest {
#[serde(rename = "DirectoryName")]
pub directory_name: String,
#[serde(rename = "OrganizationalUnitDistinguishedNames")]
pub organizational_unit_distinguished_names: Vec<String>,
#[serde(rename = "ServiceAccountCredentials")]
pub service_account_credentials: ServiceAccountCredentials,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateDirectoryConfigResult {
#[serde(rename = "DirectoryConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_config: Option<DirectoryConfig>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateFleetRequest {
#[serde(rename = "ComputeCapacity")]
pub compute_capacity: ComputeCapacity,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisconnectTimeoutInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disconnect_timeout_in_seconds: Option<i64>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "DomainJoinInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_join_info: Option<DomainJoinInfo>,
#[serde(rename = "EnableDefaultInternetAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_default_internet_access: Option<bool>,
#[serde(rename = "FleetType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_type: Option<String>,
#[serde(rename = "ImageArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_arn: Option<String>,
#[serde(rename = "ImageName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_name: Option<String>,
#[serde(rename = "InstanceType")]
pub instance_type: String,
#[serde(rename = "MaxUserDurationInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_user_duration_in_seconds: Option<i64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "VpcConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_config: Option<VpcConfig>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateFleetResult {
#[serde(rename = "Fleet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet: Option<Fleet>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateImageBuilderRequest {
#[serde(rename = "AppstreamAgentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub appstream_agent_version: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "DomainJoinInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_join_info: Option<DomainJoinInfo>,
#[serde(rename = "EnableDefaultInternetAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_default_internet_access: Option<bool>,
#[serde(rename = "ImageArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_arn: Option<String>,
#[serde(rename = "ImageName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_name: Option<String>,
#[serde(rename = "InstanceType")]
pub instance_type: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "VpcConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_config: Option<VpcConfig>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateImageBuilderResult {
#[serde(rename = "ImageBuilder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_builder: Option<ImageBuilder>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateImageBuilderStreamingURLRequest {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Validity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validity: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateImageBuilderStreamingURLResult {
#[serde(rename = "Expires")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expires: Option<f64>,
#[serde(rename = "StreamingURL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub streaming_url: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateStackRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "FeedbackURL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feedback_url: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RedirectURL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub redirect_url: Option<String>,
#[serde(rename = "StorageConnectors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage_connectors: Option<Vec<StorageConnector>>,
#[serde(rename = "UserSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_settings: Option<Vec<UserSetting>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateStackResult {
#[serde(rename = "Stack")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack: Option<Stack>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateStreamingURLRequest {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "FleetName")]
pub fleet_name: String,
#[serde(rename = "SessionContext")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session_context: Option<String>,
#[serde(rename = "StackName")]
pub stack_name: String,
#[serde(rename = "UserId")]
pub user_id: String,
#[serde(rename = "Validity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validity: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateStreamingURLResult {
#[serde(rename = "Expires")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expires: Option<f64>,
#[serde(rename = "StreamingURL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub streaming_url: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteDirectoryConfigRequest {
#[serde(rename = "DirectoryName")]
pub directory_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteDirectoryConfigResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteFleetRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteFleetResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteImageBuilderRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteImageBuilderResult {
#[serde(rename = "ImageBuilder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_builder: Option<ImageBuilder>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteImagePermissionsRequest {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SharedAccountId")]
pub shared_account_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteImagePermissionsResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteImageRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteImageResult {
#[serde(rename = "Image")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image: Option<Image>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteStackRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteStackResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeDirectoryConfigsRequest {
#[serde(rename = "DirectoryNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_names: 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(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeDirectoryConfigsResult {
#[serde(rename = "DirectoryConfigs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_configs: Option<Vec<DirectoryConfig>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeFleetsRequest {
#[serde(rename = "Names")]
#[serde(skip_serializing_if = "Option::is_none")]
pub names: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeFleetsResult {
#[serde(rename = "Fleets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleets: Option<Vec<Fleet>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeImageBuildersRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "Names")]
#[serde(skip_serializing_if = "Option::is_none")]
pub names: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeImageBuildersResult {
#[serde(rename = "ImageBuilders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_builders: Option<Vec<ImageBuilder>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeImagePermissionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SharedAwsAccountIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shared_aws_account_ids: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeImagePermissionsResult {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SharedImagePermissionsList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shared_image_permissions_list: Option<Vec<SharedImagePermissions>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeImagesRequest {
#[serde(rename = "Arns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arns: Option<Vec<String>>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "Names")]
#[serde(skip_serializing_if = "Option::is_none")]
pub names: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeImagesResult {
#[serde(rename = "Images")]
#[serde(skip_serializing_if = "Option::is_none")]
pub images: Option<Vec<Image>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeSessionsRequest {
#[serde(rename = "AuthenticationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_type: Option<String>,
#[serde(rename = "FleetName")]
pub fleet_name: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "StackName")]
pub stack_name: String,
#[serde(rename = "UserId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeSessionsResult {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Sessions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sessions: Option<Vec<Session>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeStacksRequest {
#[serde(rename = "Names")]
#[serde(skip_serializing_if = "Option::is_none")]
pub names: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeStacksResult {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Stacks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stacks: Option<Vec<Stack>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DirectoryConfig {
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "DirectoryName")]
pub directory_name: String,
#[serde(rename = "OrganizationalUnitDistinguishedNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organizational_unit_distinguished_names: Option<Vec<String>>,
#[serde(rename = "ServiceAccountCredentials")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_account_credentials: Option<ServiceAccountCredentials>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DisassociateFleetRequest {
#[serde(rename = "FleetName")]
pub fleet_name: String,
#[serde(rename = "StackName")]
pub stack_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DisassociateFleetResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DomainJoinInfo {
#[serde(rename = "DirectoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_name: Option<String>,
#[serde(rename = "OrganizationalUnitDistinguishedName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organizational_unit_distinguished_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ExpireSessionRequest {
#[serde(rename = "SessionId")]
pub session_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ExpireSessionResult {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Fleet {
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "ComputeCapacityStatus")]
pub compute_capacity_status: ComputeCapacityStatus,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisconnectTimeoutInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disconnect_timeout_in_seconds: Option<i64>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "DomainJoinInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_join_info: Option<DomainJoinInfo>,
#[serde(rename = "EnableDefaultInternetAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_default_internet_access: Option<bool>,
#[serde(rename = "FleetErrors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_errors: Option<Vec<FleetError>>,
#[serde(rename = "FleetType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_type: Option<String>,
#[serde(rename = "ImageArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_arn: Option<String>,
#[serde(rename = "ImageName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_name: Option<String>,
#[serde(rename = "InstanceType")]
pub instance_type: String,
#[serde(rename = "MaxUserDurationInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_user_duration_in_seconds: Option<i64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "State")]
pub state: String,
#[serde(rename = "VpcConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_config: Option<VpcConfig>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct FleetError {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Image {
#[serde(rename = "Applications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub applications: Option<Vec<Application>>,
#[serde(rename = "AppstreamAgentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub appstream_agent_version: Option<String>,
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "BaseImageArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base_image_arn: Option<String>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "ImageBuilderSupported")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_builder_supported: Option<bool>,
#[serde(rename = "ImagePermissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_permissions: Option<ImagePermissions>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "PublicBaseImageReleasedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_base_image_released_date: Option<f64>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "StateChangeReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_change_reason: Option<ImageStateChangeReason>,
#[serde(rename = "Visibility")]
#[serde(skip_serializing_if = "Option::is_none")]
pub visibility: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ImageBuilder {
#[serde(rename = "AppstreamAgentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub appstream_agent_version: Option<String>,
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "DomainJoinInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_join_info: Option<DomainJoinInfo>,
#[serde(rename = "EnableDefaultInternetAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_default_internet_access: Option<bool>,
#[serde(rename = "ImageArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_arn: Option<String>,
#[serde(rename = "ImageBuilderErrors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_builder_errors: Option<Vec<ResourceError>>,
#[serde(rename = "InstanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "StateChangeReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_change_reason: Option<ImageBuilderStateChangeReason>,
#[serde(rename = "VpcConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_config: Option<VpcConfig>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ImageBuilderStateChangeReason {
#[serde(rename = "Code")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ImagePermissions {
#[serde(rename = "allowFleet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_fleet: Option<bool>,
#[serde(rename = "allowImageBuilder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_image_builder: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ImageStateChangeReason {
#[serde(rename = "Code")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListAssociatedFleetsRequest {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "StackName")]
pub stack_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListAssociatedFleetsResult {
#[serde(rename = "Names")]
#[serde(skip_serializing_if = "Option::is_none")]
pub names: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListAssociatedStacksRequest {
#[serde(rename = "FleetName")]
pub fleet_name: String,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListAssociatedStacksResult {
#[serde(rename = "Names")]
#[serde(skip_serializing_if = "Option::is_none")]
pub names: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct NetworkAccessConfiguration {
#[serde(rename = "EniId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub eni_id: Option<String>,
#[serde(rename = "EniPrivateIpAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub eni_private_ip_address: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ResourceError {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "ErrorTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_timestamp: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ServiceAccountCredentials {
#[serde(rename = "AccountName")]
pub account_name: String,
#[serde(rename = "AccountPassword")]
pub account_password: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Session {
#[serde(rename = "AuthenticationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_type: Option<String>,
#[serde(rename = "FleetName")]
pub fleet_name: String,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "NetworkAccessConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_access_configuration: Option<NetworkAccessConfiguration>,
#[serde(rename = "StackName")]
pub stack_name: String,
#[serde(rename = "State")]
pub state: String,
#[serde(rename = "UserId")]
pub user_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct SharedImagePermissions {
#[serde(rename = "imagePermissions")]
pub image_permissions: ImagePermissions,
#[serde(rename = "sharedAccountId")]
pub shared_account_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Stack {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "FeedbackURL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feedback_url: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RedirectURL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub redirect_url: Option<String>,
#[serde(rename = "StackErrors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_errors: Option<Vec<StackError>>,
#[serde(rename = "StorageConnectors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage_connectors: Option<Vec<StorageConnector>>,
#[serde(rename = "UserSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_settings: Option<Vec<UserSetting>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StackError {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartFleetRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StartFleetResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartImageBuilderRequest {
#[serde(rename = "AppstreamAgentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub appstream_agent_version: Option<String>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StartImageBuilderResult {
#[serde(rename = "ImageBuilder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_builder: Option<ImageBuilder>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StopFleetRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StopFleetResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StopImageBuilderRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StopImageBuilderResult {
#[serde(rename = "ImageBuilder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_builder: Option<ImageBuilder>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StorageConnector {
#[serde(rename = "ConnectorType")]
pub connector_type: String,
#[serde(rename = "Domains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domains: Option<Vec<String>>,
#[serde(rename = "ResourceIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_identifier: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateDirectoryConfigRequest {
#[serde(rename = "DirectoryName")]
pub directory_name: String,
#[serde(rename = "OrganizationalUnitDistinguishedNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organizational_unit_distinguished_names: Option<Vec<String>>,
#[serde(rename = "ServiceAccountCredentials")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_account_credentials: Option<ServiceAccountCredentials>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateDirectoryConfigResult {
#[serde(rename = "DirectoryConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_config: Option<DirectoryConfig>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateFleetRequest {
#[serde(rename = "AttributesToDelete")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes_to_delete: Option<Vec<String>>,
#[serde(rename = "ComputeCapacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute_capacity: Option<ComputeCapacity>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisconnectTimeoutInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disconnect_timeout_in_seconds: Option<i64>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "DomainJoinInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_join_info: Option<DomainJoinInfo>,
#[serde(rename = "EnableDefaultInternetAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_default_internet_access: Option<bool>,
#[serde(rename = "ImageArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_arn: Option<String>,
#[serde(rename = "ImageName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_name: Option<String>,
#[serde(rename = "InstanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type: Option<String>,
#[serde(rename = "MaxUserDurationInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_user_duration_in_seconds: Option<i64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "VpcConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_config: Option<VpcConfig>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateFleetResult {
#[serde(rename = "Fleet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet: Option<Fleet>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateImagePermissionsRequest {
#[serde(rename = "ImagePermissions")]
pub image_permissions: ImagePermissions,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SharedAccountId")]
pub shared_account_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateImagePermissionsResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateStackRequest {
#[serde(rename = "AttributesToDelete")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes_to_delete: Option<Vec<String>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "FeedbackURL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feedback_url: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RedirectURL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub redirect_url: Option<String>,
#[serde(rename = "StorageConnectors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage_connectors: Option<Vec<StorageConnector>>,
#[serde(rename = "UserSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_settings: Option<Vec<UserSetting>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateStackResult {
#[serde(rename = "Stack")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack: Option<Stack>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UserSetting {
#[serde(rename = "Action")]
pub action: String,
#[serde(rename = "Permission")]
pub permission: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct VpcConfig {
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "SubnetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_ids: Option<Vec<String>>,
}
#[derive(Debug, PartialEq)]
pub enum AssociateFleetError {
ConcurrentModification(String),
IncompatibleImage(String),
InvalidAccountStatus(String),
LimitExceeded(String),
OperationNotPermitted(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AssociateFleetError {
pub fn from_response(res: BufferedHttpResponse) -> AssociateFleetError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return AssociateFleetError::ConcurrentModification(String::from(error_message))
}
"IncompatibleImageException" => {
return AssociateFleetError::IncompatibleImage(String::from(error_message))
}
"InvalidAccountStatusException" => {
return AssociateFleetError::InvalidAccountStatus(String::from(error_message))
}
"LimitExceededException" => {
return AssociateFleetError::LimitExceeded(String::from(error_message))
}
"OperationNotPermittedException" => {
return AssociateFleetError::OperationNotPermitted(String::from(error_message))
}
"ResourceNotFoundException" => {
return AssociateFleetError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return AssociateFleetError::Validation(error_message.to_string())
}
_ => {}
}
}
return AssociateFleetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AssociateFleetError {
fn from(err: serde_json::error::Error) -> AssociateFleetError {
AssociateFleetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AssociateFleetError {
fn from(err: CredentialsError) -> AssociateFleetError {
AssociateFleetError::Credentials(err)
}
}
impl From<HttpDispatchError> for AssociateFleetError {
fn from(err: HttpDispatchError) -> AssociateFleetError {
AssociateFleetError::HttpDispatch(err)
}
}
impl From<io::Error> for AssociateFleetError {
fn from(err: io::Error) -> AssociateFleetError {
AssociateFleetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AssociateFleetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateFleetError {
fn description(&self) -> &str {
match *self {
AssociateFleetError::ConcurrentModification(ref cause) => cause,
AssociateFleetError::IncompatibleImage(ref cause) => cause,
AssociateFleetError::InvalidAccountStatus(ref cause) => cause,
AssociateFleetError::LimitExceeded(ref cause) => cause,
AssociateFleetError::OperationNotPermitted(ref cause) => cause,
AssociateFleetError::ResourceNotFound(ref cause) => cause,
AssociateFleetError::Validation(ref cause) => cause,
AssociateFleetError::Credentials(ref err) => err.description(),
AssociateFleetError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
AssociateFleetError::ParseError(ref cause) => cause,
AssociateFleetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CopyImageError {
IncompatibleImage(String),
InvalidAccountStatus(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ResourceNotAvailable(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CopyImageError {
pub fn from_response(res: BufferedHttpResponse) -> CopyImageError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"IncompatibleImageException" => {
return CopyImageError::IncompatibleImage(String::from(error_message))
}
"InvalidAccountStatusException" => {
return CopyImageError::InvalidAccountStatus(String::from(error_message))
}
"LimitExceededException" => {
return CopyImageError::LimitExceeded(String::from(error_message))
}
"ResourceAlreadyExistsException" => {
return CopyImageError::ResourceAlreadyExists(String::from(error_message))
}
"ResourceNotAvailableException" => {
return CopyImageError::ResourceNotAvailable(String::from(error_message))
}
"ResourceNotFoundException" => {
return CopyImageError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return CopyImageError::Validation(error_message.to_string())
}
_ => {}
}
}
return CopyImageError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CopyImageError {
fn from(err: serde_json::error::Error) -> CopyImageError {
CopyImageError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CopyImageError {
fn from(err: CredentialsError) -> CopyImageError {
CopyImageError::Credentials(err)
}
}
impl From<HttpDispatchError> for CopyImageError {
fn from(err: HttpDispatchError) -> CopyImageError {
CopyImageError::HttpDispatch(err)
}
}
impl From<io::Error> for CopyImageError {
fn from(err: io::Error) -> CopyImageError {
CopyImageError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CopyImageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CopyImageError {
fn description(&self) -> &str {
match *self {
CopyImageError::IncompatibleImage(ref cause) => cause,
CopyImageError::InvalidAccountStatus(ref cause) => cause,
CopyImageError::LimitExceeded(ref cause) => cause,
CopyImageError::ResourceAlreadyExists(ref cause) => cause,
CopyImageError::ResourceNotAvailable(ref cause) => cause,
CopyImageError::ResourceNotFound(ref cause) => cause,
CopyImageError::Validation(ref cause) => cause,
CopyImageError::Credentials(ref err) => err.description(),
CopyImageError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CopyImageError::ParseError(ref cause) => cause,
CopyImageError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDirectoryConfigError {
InvalidAccountStatus(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDirectoryConfigError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDirectoryConfigError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidAccountStatusException" => {
return CreateDirectoryConfigError::InvalidAccountStatus(String::from(
error_message,
))
}
"LimitExceededException" => {
return CreateDirectoryConfigError::LimitExceeded(String::from(error_message))
}
"ResourceAlreadyExistsException" => {
return CreateDirectoryConfigError::ResourceAlreadyExists(String::from(
error_message,
))
}
"ValidationException" => {
return CreateDirectoryConfigError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateDirectoryConfigError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateDirectoryConfigError {
fn from(err: serde_json::error::Error) -> CreateDirectoryConfigError {
CreateDirectoryConfigError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateDirectoryConfigError {
fn from(err: CredentialsError) -> CreateDirectoryConfigError {
CreateDirectoryConfigError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDirectoryConfigError {
fn from(err: HttpDispatchError) -> CreateDirectoryConfigError {
CreateDirectoryConfigError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDirectoryConfigError {
fn from(err: io::Error) -> CreateDirectoryConfigError {
CreateDirectoryConfigError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDirectoryConfigError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDirectoryConfigError {
fn description(&self) -> &str {
match *self {
CreateDirectoryConfigError::InvalidAccountStatus(ref cause) => cause,
CreateDirectoryConfigError::LimitExceeded(ref cause) => cause,
CreateDirectoryConfigError::ResourceAlreadyExists(ref cause) => cause,
CreateDirectoryConfigError::Validation(ref cause) => cause,
CreateDirectoryConfigError::Credentials(ref err) => err.description(),
CreateDirectoryConfigError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateDirectoryConfigError::ParseError(ref cause) => cause,
CreateDirectoryConfigError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateFleetError {
ConcurrentModification(String),
IncompatibleImage(String),
InvalidAccountStatus(String),
InvalidParameterCombination(String),
InvalidRole(String),
LimitExceeded(String),
OperationNotPermitted(String),
ResourceAlreadyExists(String),
ResourceNotAvailable(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateFleetError {
pub fn from_response(res: BufferedHttpResponse) -> CreateFleetError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return CreateFleetError::ConcurrentModification(String::from(error_message))
}
"IncompatibleImageException" => {
return CreateFleetError::IncompatibleImage(String::from(error_message))
}
"InvalidAccountStatusException" => {
return CreateFleetError::InvalidAccountStatus(String::from(error_message))
}
"InvalidParameterCombinationException" => {
return CreateFleetError::InvalidParameterCombination(String::from(
error_message,
))
}
"InvalidRoleException" => {
return CreateFleetError::InvalidRole(String::from(error_message))
}
"LimitExceededException" => {
return CreateFleetError::LimitExceeded(String::from(error_message))
}
"OperationNotPermittedException" => {
return CreateFleetError::OperationNotPermitted(String::from(error_message))
}
"ResourceAlreadyExistsException" => {
return CreateFleetError::ResourceAlreadyExists(String::from(error_message))
}
"ResourceNotAvailableException" => {
return CreateFleetError::ResourceNotAvailable(String::from(error_message))
}
"ResourceNotFoundException" => {
return CreateFleetError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return CreateFleetError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateFleetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateFleetError {
fn from(err: serde_json::error::Error) -> CreateFleetError {
CreateFleetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateFleetError {
fn from(err: CredentialsError) -> CreateFleetError {
CreateFleetError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateFleetError {
fn from(err: HttpDispatchError) -> CreateFleetError {
CreateFleetError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateFleetError {
fn from(err: io::Error) -> CreateFleetError {
CreateFleetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateFleetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateFleetError {
fn description(&self) -> &str {
match *self {
CreateFleetError::ConcurrentModification(ref cause) => cause,
CreateFleetError::IncompatibleImage(ref cause) => cause,
CreateFleetError::InvalidAccountStatus(ref cause) => cause,
CreateFleetError::InvalidParameterCombination(ref cause) => cause,
CreateFleetError::InvalidRole(ref cause) => cause,
CreateFleetError::LimitExceeded(ref cause) => cause,
CreateFleetError::OperationNotPermitted(ref cause) => cause,
CreateFleetError::ResourceAlreadyExists(ref cause) => cause,
CreateFleetError::ResourceNotAvailable(ref cause) => cause,
CreateFleetError::ResourceNotFound(ref cause) => cause,
CreateFleetError::Validation(ref cause) => cause,
CreateFleetError::Credentials(ref err) => err.description(),
CreateFleetError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateFleetError::ParseError(ref cause) => cause,
CreateFleetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateImageBuilderError {
ConcurrentModification(String),
IncompatibleImage(String),
InvalidAccountStatus(String),
InvalidParameterCombination(String),
InvalidRole(String),
LimitExceeded(String),
OperationNotPermitted(String),
ResourceAlreadyExists(String),
ResourceNotAvailable(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateImageBuilderError {
pub fn from_response(res: BufferedHttpResponse) -> CreateImageBuilderError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return CreateImageBuilderError::ConcurrentModification(String::from(
error_message,
))
}
"IncompatibleImageException" => {
return CreateImageBuilderError::IncompatibleImage(String::from(error_message))
}
"InvalidAccountStatusException" => {
return CreateImageBuilderError::InvalidAccountStatus(String::from(
error_message,
))
}
"InvalidParameterCombinationException" => {
return CreateImageBuilderError::InvalidParameterCombination(String::from(
error_message,
))
}
"InvalidRoleException" => {
return CreateImageBuilderError::InvalidRole(String::from(error_message))
}
"LimitExceededException" => {
return CreateImageBuilderError::LimitExceeded(String::from(error_message))
}
"OperationNotPermittedException" => {
return CreateImageBuilderError::OperationNotPermitted(String::from(
error_message,
))
}
"ResourceAlreadyExistsException" => {
return CreateImageBuilderError::ResourceAlreadyExists(String::from(
error_message,
))
}
"ResourceNotAvailableException" => {
return CreateImageBuilderError::ResourceNotAvailable(String::from(
error_message,
))
}
"ResourceNotFoundException" => {
return CreateImageBuilderError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return CreateImageBuilderError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateImageBuilderError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateImageBuilderError {
fn from(err: serde_json::error::Error) -> CreateImageBuilderError {
CreateImageBuilderError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateImageBuilderError {
fn from(err: CredentialsError) -> CreateImageBuilderError {
CreateImageBuilderError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateImageBuilderError {
fn from(err: HttpDispatchError) -> CreateImageBuilderError {
CreateImageBuilderError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateImageBuilderError {
fn from(err: io::Error) -> CreateImageBuilderError {
CreateImageBuilderError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateImageBuilderError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateImageBuilderError {
fn description(&self) -> &str {
match *self {
CreateImageBuilderError::ConcurrentModification(ref cause) => cause,
CreateImageBuilderError::IncompatibleImage(ref cause) => cause,
CreateImageBuilderError::InvalidAccountStatus(ref cause) => cause,
CreateImageBuilderError::InvalidParameterCombination(ref cause) => cause,
CreateImageBuilderError::InvalidRole(ref cause) => cause,
CreateImageBuilderError::LimitExceeded(ref cause) => cause,
CreateImageBuilderError::OperationNotPermitted(ref cause) => cause,
CreateImageBuilderError::ResourceAlreadyExists(ref cause) => cause,
CreateImageBuilderError::ResourceNotAvailable(ref cause) => cause,
CreateImageBuilderError::ResourceNotFound(ref cause) => cause,
CreateImageBuilderError::Validation(ref cause) => cause,
CreateImageBuilderError::Credentials(ref err) => err.description(),
CreateImageBuilderError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateImageBuilderError::ParseError(ref cause) => cause,
CreateImageBuilderError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateImageBuilderStreamingURLError {
OperationNotPermitted(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateImageBuilderStreamingURLError {
pub fn from_response(res: BufferedHttpResponse) -> CreateImageBuilderStreamingURLError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"OperationNotPermittedException" => {
return CreateImageBuilderStreamingURLError::OperationNotPermitted(String::from(
error_message,
))
}
"ResourceNotFoundException" => {
return CreateImageBuilderStreamingURLError::ResourceNotFound(String::from(
error_message,
))
}
"ValidationException" => {
return CreateImageBuilderStreamingURLError::Validation(
error_message.to_string(),
)
}
_ => {}
}
}
return CreateImageBuilderStreamingURLError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateImageBuilderStreamingURLError {
fn from(err: serde_json::error::Error) -> CreateImageBuilderStreamingURLError {
CreateImageBuilderStreamingURLError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateImageBuilderStreamingURLError {
fn from(err: CredentialsError) -> CreateImageBuilderStreamingURLError {
CreateImageBuilderStreamingURLError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateImageBuilderStreamingURLError {
fn from(err: HttpDispatchError) -> CreateImageBuilderStreamingURLError {
CreateImageBuilderStreamingURLError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateImageBuilderStreamingURLError {
fn from(err: io::Error) -> CreateImageBuilderStreamingURLError {
CreateImageBuilderStreamingURLError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateImageBuilderStreamingURLError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateImageBuilderStreamingURLError {
fn description(&self) -> &str {
match *self {
CreateImageBuilderStreamingURLError::OperationNotPermitted(ref cause) => cause,
CreateImageBuilderStreamingURLError::ResourceNotFound(ref cause) => cause,
CreateImageBuilderStreamingURLError::Validation(ref cause) => cause,
CreateImageBuilderStreamingURLError::Credentials(ref err) => err.description(),
CreateImageBuilderStreamingURLError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateImageBuilderStreamingURLError::ParseError(ref cause) => cause,
CreateImageBuilderStreamingURLError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateStackError {
ConcurrentModification(String),
InvalidAccountStatus(String),
InvalidParameterCombination(String),
InvalidRole(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateStackError {
pub fn from_response(res: BufferedHttpResponse) -> CreateStackError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return CreateStackError::ConcurrentModification(String::from(error_message))
}
"InvalidAccountStatusException" => {
return CreateStackError::InvalidAccountStatus(String::from(error_message))
}
"InvalidParameterCombinationException" => {
return CreateStackError::InvalidParameterCombination(String::from(
error_message,
))
}
"InvalidRoleException" => {
return CreateStackError::InvalidRole(String::from(error_message))
}
"LimitExceededException" => {
return CreateStackError::LimitExceeded(String::from(error_message))
}
"ResourceAlreadyExistsException" => {
return CreateStackError::ResourceAlreadyExists(String::from(error_message))
}
"ResourceNotFoundException" => {
return CreateStackError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return CreateStackError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateStackError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateStackError {
fn from(err: serde_json::error::Error) -> CreateStackError {
CreateStackError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateStackError {
fn from(err: CredentialsError) -> CreateStackError {
CreateStackError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateStackError {
fn from(err: HttpDispatchError) -> CreateStackError {
CreateStackError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateStackError {
fn from(err: io::Error) -> CreateStackError {
CreateStackError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateStackError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateStackError {
fn description(&self) -> &str {
match *self {
CreateStackError::ConcurrentModification(ref cause) => cause,
CreateStackError::InvalidAccountStatus(ref cause) => cause,
CreateStackError::InvalidParameterCombination(ref cause) => cause,
CreateStackError::InvalidRole(ref cause) => cause,
CreateStackError::LimitExceeded(ref cause) => cause,
CreateStackError::ResourceAlreadyExists(ref cause) => cause,
CreateStackError::ResourceNotFound(ref cause) => cause,
CreateStackError::Validation(ref cause) => cause,
CreateStackError::Credentials(ref err) => err.description(),
CreateStackError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateStackError::ParseError(ref cause) => cause,
CreateStackError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateStreamingURLError {
InvalidParameterCombination(String),
OperationNotPermitted(String),
ResourceNotAvailable(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateStreamingURLError {
pub fn from_response(res: BufferedHttpResponse) -> CreateStreamingURLError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidParameterCombinationException" => {
return CreateStreamingURLError::InvalidParameterCombination(String::from(
error_message,
))
}
"OperationNotPermittedException" => {
return CreateStreamingURLError::OperationNotPermitted(String::from(
error_message,
))
}
"ResourceNotAvailableException" => {
return CreateStreamingURLError::ResourceNotAvailable(String::from(
error_message,
))
}
"ResourceNotFoundException" => {
return CreateStreamingURLError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return CreateStreamingURLError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateStreamingURLError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateStreamingURLError {
fn from(err: serde_json::error::Error) -> CreateStreamingURLError {
CreateStreamingURLError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateStreamingURLError {
fn from(err: CredentialsError) -> CreateStreamingURLError {
CreateStreamingURLError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateStreamingURLError {
fn from(err: HttpDispatchError) -> CreateStreamingURLError {
CreateStreamingURLError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateStreamingURLError {
fn from(err: io::Error) -> CreateStreamingURLError {
CreateStreamingURLError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateStreamingURLError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateStreamingURLError {
fn description(&self) -> &str {
match *self {
CreateStreamingURLError::InvalidParameterCombination(ref cause) => cause,
CreateStreamingURLError::OperationNotPermitted(ref cause) => cause,
CreateStreamingURLError::ResourceNotAvailable(ref cause) => cause,
CreateStreamingURLError::ResourceNotFound(ref cause) => cause,
CreateStreamingURLError::Validation(ref cause) => cause,
CreateStreamingURLError::Credentials(ref err) => err.description(),
CreateStreamingURLError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateStreamingURLError::ParseError(ref cause) => cause,
CreateStreamingURLError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteDirectoryConfigError {
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteDirectoryConfigError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteDirectoryConfigError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceInUseException" => {
return DeleteDirectoryConfigError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return DeleteDirectoryConfigError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DeleteDirectoryConfigError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteDirectoryConfigError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteDirectoryConfigError {
fn from(err: serde_json::error::Error) -> DeleteDirectoryConfigError {
DeleteDirectoryConfigError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteDirectoryConfigError {
fn from(err: CredentialsError) -> DeleteDirectoryConfigError {
DeleteDirectoryConfigError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteDirectoryConfigError {
fn from(err: HttpDispatchError) -> DeleteDirectoryConfigError {
DeleteDirectoryConfigError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteDirectoryConfigError {
fn from(err: io::Error) -> DeleteDirectoryConfigError {
DeleteDirectoryConfigError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteDirectoryConfigError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDirectoryConfigError {
fn description(&self) -> &str {
match *self {
DeleteDirectoryConfigError::ResourceInUse(ref cause) => cause,
DeleteDirectoryConfigError::ResourceNotFound(ref cause) => cause,
DeleteDirectoryConfigError::Validation(ref cause) => cause,
DeleteDirectoryConfigError::Credentials(ref err) => err.description(),
DeleteDirectoryConfigError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteDirectoryConfigError::ParseError(ref cause) => cause,
DeleteDirectoryConfigError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteFleetError {
ConcurrentModification(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteFleetError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteFleetError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return DeleteFleetError::ConcurrentModification(String::from(error_message))
}
"ResourceInUseException" => {
return DeleteFleetError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return DeleteFleetError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DeleteFleetError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteFleetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteFleetError {
fn from(err: serde_json::error::Error) -> DeleteFleetError {
DeleteFleetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteFleetError {
fn from(err: CredentialsError) -> DeleteFleetError {
DeleteFleetError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteFleetError {
fn from(err: HttpDispatchError) -> DeleteFleetError {
DeleteFleetError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteFleetError {
fn from(err: io::Error) -> DeleteFleetError {
DeleteFleetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteFleetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteFleetError {
fn description(&self) -> &str {
match *self {
DeleteFleetError::ConcurrentModification(ref cause) => cause,
DeleteFleetError::ResourceInUse(ref cause) => cause,
DeleteFleetError::ResourceNotFound(ref cause) => cause,
DeleteFleetError::Validation(ref cause) => cause,
DeleteFleetError::Credentials(ref err) => err.description(),
DeleteFleetError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteFleetError::ParseError(ref cause) => cause,
DeleteFleetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteImageError {
ConcurrentModification(String),
OperationNotPermitted(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteImageError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteImageError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return DeleteImageError::ConcurrentModification(String::from(error_message))
}
"OperationNotPermittedException" => {
return DeleteImageError::OperationNotPermitted(String::from(error_message))
}
"ResourceInUseException" => {
return DeleteImageError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return DeleteImageError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DeleteImageError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteImageError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteImageError {
fn from(err: serde_json::error::Error) -> DeleteImageError {
DeleteImageError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteImageError {
fn from(err: CredentialsError) -> DeleteImageError {
DeleteImageError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteImageError {
fn from(err: HttpDispatchError) -> DeleteImageError {
DeleteImageError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteImageError {
fn from(err: io::Error) -> DeleteImageError {
DeleteImageError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteImageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteImageError {
fn description(&self) -> &str {
match *self {
DeleteImageError::ConcurrentModification(ref cause) => cause,
DeleteImageError::OperationNotPermitted(ref cause) => cause,
DeleteImageError::ResourceInUse(ref cause) => cause,
DeleteImageError::ResourceNotFound(ref cause) => cause,
DeleteImageError::Validation(ref cause) => cause,
DeleteImageError::Credentials(ref err) => err.description(),
DeleteImageError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteImageError::ParseError(ref cause) => cause,
DeleteImageError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteImageBuilderError {
ConcurrentModification(String),
OperationNotPermitted(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteImageBuilderError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteImageBuilderError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return DeleteImageBuilderError::ConcurrentModification(String::from(
error_message,
))
}
"OperationNotPermittedException" => {
return DeleteImageBuilderError::OperationNotPermitted(String::from(
error_message,
))
}
"ResourceNotFoundException" => {
return DeleteImageBuilderError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DeleteImageBuilderError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteImageBuilderError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteImageBuilderError {
fn from(err: serde_json::error::Error) -> DeleteImageBuilderError {
DeleteImageBuilderError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteImageBuilderError {
fn from(err: CredentialsError) -> DeleteImageBuilderError {
DeleteImageBuilderError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteImageBuilderError {
fn from(err: HttpDispatchError) -> DeleteImageBuilderError {
DeleteImageBuilderError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteImageBuilderError {
fn from(err: io::Error) -> DeleteImageBuilderError {
DeleteImageBuilderError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteImageBuilderError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteImageBuilderError {
fn description(&self) -> &str {
match *self {
DeleteImageBuilderError::ConcurrentModification(ref cause) => cause,
DeleteImageBuilderError::OperationNotPermitted(ref cause) => cause,
DeleteImageBuilderError::ResourceNotFound(ref cause) => cause,
DeleteImageBuilderError::Validation(ref cause) => cause,
DeleteImageBuilderError::Credentials(ref err) => err.description(),
DeleteImageBuilderError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteImageBuilderError::ParseError(ref cause) => cause,
DeleteImageBuilderError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteImagePermissionsError {
ResourceNotAvailable(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteImagePermissionsError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteImagePermissionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotAvailableException" => {
return DeleteImagePermissionsError::ResourceNotAvailable(String::from(
error_message,
))
}
"ResourceNotFoundException" => {
return DeleteImagePermissionsError::ResourceNotFound(String::from(
error_message,
))
}
"ValidationException" => {
return DeleteImagePermissionsError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteImagePermissionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteImagePermissionsError {
fn from(err: serde_json::error::Error) -> DeleteImagePermissionsError {
DeleteImagePermissionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteImagePermissionsError {
fn from(err: CredentialsError) -> DeleteImagePermissionsError {
DeleteImagePermissionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteImagePermissionsError {
fn from(err: HttpDispatchError) -> DeleteImagePermissionsError {
DeleteImagePermissionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteImagePermissionsError {
fn from(err: io::Error) -> DeleteImagePermissionsError {
DeleteImagePermissionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteImagePermissionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteImagePermissionsError {
fn description(&self) -> &str {
match *self {
DeleteImagePermissionsError::ResourceNotAvailable(ref cause) => cause,
DeleteImagePermissionsError::ResourceNotFound(ref cause) => cause,
DeleteImagePermissionsError::Validation(ref cause) => cause,
DeleteImagePermissionsError::Credentials(ref err) => err.description(),
DeleteImagePermissionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteImagePermissionsError::ParseError(ref cause) => cause,
DeleteImagePermissionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteStackError {
ConcurrentModification(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteStackError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteStackError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return DeleteStackError::ConcurrentModification(String::from(error_message))
}
"ResourceInUseException" => {
return DeleteStackError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return DeleteStackError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DeleteStackError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteStackError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteStackError {
fn from(err: serde_json::error::Error) -> DeleteStackError {
DeleteStackError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteStackError {
fn from(err: CredentialsError) -> DeleteStackError {
DeleteStackError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteStackError {
fn from(err: HttpDispatchError) -> DeleteStackError {
DeleteStackError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteStackError {
fn from(err: io::Error) -> DeleteStackError {
DeleteStackError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteStackError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteStackError {
fn description(&self) -> &str {
match *self {
DeleteStackError::ConcurrentModification(ref cause) => cause,
DeleteStackError::ResourceInUse(ref cause) => cause,
DeleteStackError::ResourceNotFound(ref cause) => cause,
DeleteStackError::Validation(ref cause) => cause,
DeleteStackError::Credentials(ref err) => err.description(),
DeleteStackError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteStackError::ParseError(ref cause) => cause,
DeleteStackError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeDirectoryConfigsError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeDirectoryConfigsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeDirectoryConfigsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeDirectoryConfigsError::ResourceNotFound(String::from(
error_message,
))
}
"ValidationException" => {
return DescribeDirectoryConfigsError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeDirectoryConfigsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeDirectoryConfigsError {
fn from(err: serde_json::error::Error) -> DescribeDirectoryConfigsError {
DescribeDirectoryConfigsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeDirectoryConfigsError {
fn from(err: CredentialsError) -> DescribeDirectoryConfigsError {
DescribeDirectoryConfigsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeDirectoryConfigsError {
fn from(err: HttpDispatchError) -> DescribeDirectoryConfigsError {
DescribeDirectoryConfigsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeDirectoryConfigsError {
fn from(err: io::Error) -> DescribeDirectoryConfigsError {
DescribeDirectoryConfigsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeDirectoryConfigsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeDirectoryConfigsError {
fn description(&self) -> &str {
match *self {
DescribeDirectoryConfigsError::ResourceNotFound(ref cause) => cause,
DescribeDirectoryConfigsError::Validation(ref cause) => cause,
DescribeDirectoryConfigsError::Credentials(ref err) => err.description(),
DescribeDirectoryConfigsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeDirectoryConfigsError::ParseError(ref cause) => cause,
DescribeDirectoryConfigsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeFleetsError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeFleetsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeFleetsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeFleetsError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DescribeFleetsError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeFleetsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeFleetsError {
fn from(err: serde_json::error::Error) -> DescribeFleetsError {
DescribeFleetsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeFleetsError {
fn from(err: CredentialsError) -> DescribeFleetsError {
DescribeFleetsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeFleetsError {
fn from(err: HttpDispatchError) -> DescribeFleetsError {
DescribeFleetsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeFleetsError {
fn from(err: io::Error) -> DescribeFleetsError {
DescribeFleetsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeFleetsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeFleetsError {
fn description(&self) -> &str {
match *self {
DescribeFleetsError::ResourceNotFound(ref cause) => cause,
DescribeFleetsError::Validation(ref cause) => cause,
DescribeFleetsError::Credentials(ref err) => err.description(),
DescribeFleetsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeFleetsError::ParseError(ref cause) => cause,
DescribeFleetsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeImageBuildersError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeImageBuildersError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeImageBuildersError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeImageBuildersError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DescribeImageBuildersError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeImageBuildersError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeImageBuildersError {
fn from(err: serde_json::error::Error) -> DescribeImageBuildersError {
DescribeImageBuildersError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeImageBuildersError {
fn from(err: CredentialsError) -> DescribeImageBuildersError {
DescribeImageBuildersError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeImageBuildersError {
fn from(err: HttpDispatchError) -> DescribeImageBuildersError {
DescribeImageBuildersError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeImageBuildersError {
fn from(err: io::Error) -> DescribeImageBuildersError {
DescribeImageBuildersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeImageBuildersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeImageBuildersError {
fn description(&self) -> &str {
match *self {
DescribeImageBuildersError::ResourceNotFound(ref cause) => cause,
DescribeImageBuildersError::Validation(ref cause) => cause,
DescribeImageBuildersError::Credentials(ref err) => err.description(),
DescribeImageBuildersError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeImageBuildersError::ParseError(ref cause) => cause,
DescribeImageBuildersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeImagePermissionsError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeImagePermissionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeImagePermissionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeImagePermissionsError::ResourceNotFound(String::from(
error_message,
))
}
"ValidationException" => {
return DescribeImagePermissionsError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeImagePermissionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeImagePermissionsError {
fn from(err: serde_json::error::Error) -> DescribeImagePermissionsError {
DescribeImagePermissionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeImagePermissionsError {
fn from(err: CredentialsError) -> DescribeImagePermissionsError {
DescribeImagePermissionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeImagePermissionsError {
fn from(err: HttpDispatchError) -> DescribeImagePermissionsError {
DescribeImagePermissionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeImagePermissionsError {
fn from(err: io::Error) -> DescribeImagePermissionsError {
DescribeImagePermissionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeImagePermissionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeImagePermissionsError {
fn description(&self) -> &str {
match *self {
DescribeImagePermissionsError::ResourceNotFound(ref cause) => cause,
DescribeImagePermissionsError::Validation(ref cause) => cause,
DescribeImagePermissionsError::Credentials(ref err) => err.description(),
DescribeImagePermissionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeImagePermissionsError::ParseError(ref cause) => cause,
DescribeImagePermissionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeImagesError {
InvalidParameterCombination(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeImagesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeImagesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidParameterCombinationException" => {
return DescribeImagesError::InvalidParameterCombination(String::from(
error_message,
))
}
"ResourceNotFoundException" => {
return DescribeImagesError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DescribeImagesError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeImagesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeImagesError {
fn from(err: serde_json::error::Error) -> DescribeImagesError {
DescribeImagesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeImagesError {
fn from(err: CredentialsError) -> DescribeImagesError {
DescribeImagesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeImagesError {
fn from(err: HttpDispatchError) -> DescribeImagesError {
DescribeImagesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeImagesError {
fn from(err: io::Error) -> DescribeImagesError {
DescribeImagesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeImagesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeImagesError {
fn description(&self) -> &str {
match *self {
DescribeImagesError::InvalidParameterCombination(ref cause) => cause,
DescribeImagesError::ResourceNotFound(ref cause) => cause,
DescribeImagesError::Validation(ref cause) => cause,
DescribeImagesError::Credentials(ref err) => err.description(),
DescribeImagesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeImagesError::ParseError(ref cause) => cause,
DescribeImagesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeSessionsError {
InvalidParameterCombination(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeSessionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeSessionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidParameterCombinationException" => {
return DescribeSessionsError::InvalidParameterCombination(String::from(
error_message,
))
}
"ValidationException" => {
return DescribeSessionsError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeSessionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeSessionsError {
fn from(err: serde_json::error::Error) -> DescribeSessionsError {
DescribeSessionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeSessionsError {
fn from(err: CredentialsError) -> DescribeSessionsError {
DescribeSessionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeSessionsError {
fn from(err: HttpDispatchError) -> DescribeSessionsError {
DescribeSessionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeSessionsError {
fn from(err: io::Error) -> DescribeSessionsError {
DescribeSessionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeSessionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeSessionsError {
fn description(&self) -> &str {
match *self {
DescribeSessionsError::InvalidParameterCombination(ref cause) => cause,
DescribeSessionsError::Validation(ref cause) => cause,
DescribeSessionsError::Credentials(ref err) => err.description(),
DescribeSessionsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeSessionsError::ParseError(ref cause) => cause,
DescribeSessionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeStacksError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeStacksError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeStacksError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeStacksError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DescribeStacksError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeStacksError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeStacksError {
fn from(err: serde_json::error::Error) -> DescribeStacksError {
DescribeStacksError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeStacksError {
fn from(err: CredentialsError) -> DescribeStacksError {
DescribeStacksError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeStacksError {
fn from(err: HttpDispatchError) -> DescribeStacksError {
DescribeStacksError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeStacksError {
fn from(err: io::Error) -> DescribeStacksError {
DescribeStacksError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeStacksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeStacksError {
fn description(&self) -> &str {
match *self {
DescribeStacksError::ResourceNotFound(ref cause) => cause,
DescribeStacksError::Validation(ref cause) => cause,
DescribeStacksError::Credentials(ref err) => err.description(),
DescribeStacksError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeStacksError::ParseError(ref cause) => cause,
DescribeStacksError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateFleetError {
ConcurrentModification(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisassociateFleetError {
pub fn from_response(res: BufferedHttpResponse) -> DisassociateFleetError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return DisassociateFleetError::ConcurrentModification(String::from(
error_message,
))
}
"ResourceInUseException" => {
return DisassociateFleetError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return DisassociateFleetError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DisassociateFleetError::Validation(error_message.to_string())
}
_ => {}
}
}
return DisassociateFleetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DisassociateFleetError {
fn from(err: serde_json::error::Error) -> DisassociateFleetError {
DisassociateFleetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DisassociateFleetError {
fn from(err: CredentialsError) -> DisassociateFleetError {
DisassociateFleetError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisassociateFleetError {
fn from(err: HttpDispatchError) -> DisassociateFleetError {
DisassociateFleetError::HttpDispatch(err)
}
}
impl From<io::Error> for DisassociateFleetError {
fn from(err: io::Error) -> DisassociateFleetError {
DisassociateFleetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisassociateFleetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateFleetError {
fn description(&self) -> &str {
match *self {
DisassociateFleetError::ConcurrentModification(ref cause) => cause,
DisassociateFleetError::ResourceInUse(ref cause) => cause,
DisassociateFleetError::ResourceNotFound(ref cause) => cause,
DisassociateFleetError::Validation(ref cause) => cause,
DisassociateFleetError::Credentials(ref err) => err.description(),
DisassociateFleetError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DisassociateFleetError::ParseError(ref cause) => cause,
DisassociateFleetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ExpireSessionError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ExpireSessionError {
pub fn from_response(res: BufferedHttpResponse) -> ExpireSessionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ValidationException" => {
return ExpireSessionError::Validation(error_message.to_string())
}
_ => {}
}
}
return ExpireSessionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ExpireSessionError {
fn from(err: serde_json::error::Error) -> ExpireSessionError {
ExpireSessionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ExpireSessionError {
fn from(err: CredentialsError) -> ExpireSessionError {
ExpireSessionError::Credentials(err)
}
}
impl From<HttpDispatchError> for ExpireSessionError {
fn from(err: HttpDispatchError) -> ExpireSessionError {
ExpireSessionError::HttpDispatch(err)
}
}
impl From<io::Error> for ExpireSessionError {
fn from(err: io::Error) -> ExpireSessionError {
ExpireSessionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ExpireSessionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ExpireSessionError {
fn description(&self) -> &str {
match *self {
ExpireSessionError::Validation(ref cause) => cause,
ExpireSessionError::Credentials(ref err) => err.description(),
ExpireSessionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ExpireSessionError::ParseError(ref cause) => cause,
ExpireSessionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListAssociatedFleetsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListAssociatedFleetsError {
pub fn from_response(res: BufferedHttpResponse) -> ListAssociatedFleetsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ValidationException" => {
return ListAssociatedFleetsError::Validation(error_message.to_string())
}
_ => {}
}
}
return ListAssociatedFleetsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListAssociatedFleetsError {
fn from(err: serde_json::error::Error) -> ListAssociatedFleetsError {
ListAssociatedFleetsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListAssociatedFleetsError {
fn from(err: CredentialsError) -> ListAssociatedFleetsError {
ListAssociatedFleetsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListAssociatedFleetsError {
fn from(err: HttpDispatchError) -> ListAssociatedFleetsError {
ListAssociatedFleetsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListAssociatedFleetsError {
fn from(err: io::Error) -> ListAssociatedFleetsError {
ListAssociatedFleetsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListAssociatedFleetsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListAssociatedFleetsError {
fn description(&self) -> &str {
match *self {
ListAssociatedFleetsError::Validation(ref cause) => cause,
ListAssociatedFleetsError::Credentials(ref err) => err.description(),
ListAssociatedFleetsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListAssociatedFleetsError::ParseError(ref cause) => cause,
ListAssociatedFleetsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListAssociatedStacksError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListAssociatedStacksError {
pub fn from_response(res: BufferedHttpResponse) -> ListAssociatedStacksError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ValidationException" => {
return ListAssociatedStacksError::Validation(error_message.to_string())
}
_ => {}
}
}
return ListAssociatedStacksError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListAssociatedStacksError {
fn from(err: serde_json::error::Error) -> ListAssociatedStacksError {
ListAssociatedStacksError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListAssociatedStacksError {
fn from(err: CredentialsError) -> ListAssociatedStacksError {
ListAssociatedStacksError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListAssociatedStacksError {
fn from(err: HttpDispatchError) -> ListAssociatedStacksError {
ListAssociatedStacksError::HttpDispatch(err)
}
}
impl From<io::Error> for ListAssociatedStacksError {
fn from(err: io::Error) -> ListAssociatedStacksError {
ListAssociatedStacksError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListAssociatedStacksError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListAssociatedStacksError {
fn description(&self) -> &str {
match *self {
ListAssociatedStacksError::Validation(ref cause) => cause,
ListAssociatedStacksError::Credentials(ref err) => err.description(),
ListAssociatedStacksError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListAssociatedStacksError::ParseError(ref cause) => cause,
ListAssociatedStacksError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> ListTagsForResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return ListTagsForResourceError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return ListTagsForResourceError::Validation(error_message.to_string())
}
_ => {}
}
}
return ListTagsForResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListTagsForResourceError {
fn from(err: serde_json::error::Error) -> ListTagsForResourceError {
ListTagsForResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListTagsForResourceError {
fn from(err: CredentialsError) -> ListTagsForResourceError {
ListTagsForResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTagsForResourceError {
fn from(err: HttpDispatchError) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTagsForResourceError {
fn from(err: io::Error) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTagsForResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTagsForResourceError {
fn description(&self) -> &str {
match *self {
ListTagsForResourceError::ResourceNotFound(ref cause) => cause,
ListTagsForResourceError::Validation(ref cause) => cause,
ListTagsForResourceError::Credentials(ref err) => err.description(),
ListTagsForResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTagsForResourceError::ParseError(ref cause) => cause,
ListTagsForResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartFleetError {
ConcurrentModification(String),
InvalidAccountStatus(String),
LimitExceeded(String),
OperationNotPermitted(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartFleetError {
pub fn from_response(res: BufferedHttpResponse) -> StartFleetError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return StartFleetError::ConcurrentModification(String::from(error_message))
}
"InvalidAccountStatusException" => {
return StartFleetError::InvalidAccountStatus(String::from(error_message))
}
"LimitExceededException" => {
return StartFleetError::LimitExceeded(String::from(error_message))
}
"OperationNotPermittedException" => {
return StartFleetError::OperationNotPermitted(String::from(error_message))
}
"ResourceNotFoundException" => {
return StartFleetError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return StartFleetError::Validation(error_message.to_string())
}
_ => {}
}
}
return StartFleetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartFleetError {
fn from(err: serde_json::error::Error) -> StartFleetError {
StartFleetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartFleetError {
fn from(err: CredentialsError) -> StartFleetError {
StartFleetError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartFleetError {
fn from(err: HttpDispatchError) -> StartFleetError {
StartFleetError::HttpDispatch(err)
}
}
impl From<io::Error> for StartFleetError {
fn from(err: io::Error) -> StartFleetError {
StartFleetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartFleetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartFleetError {
fn description(&self) -> &str {
match *self {
StartFleetError::ConcurrentModification(ref cause) => cause,
StartFleetError::InvalidAccountStatus(ref cause) => cause,
StartFleetError::LimitExceeded(ref cause) => cause,
StartFleetError::OperationNotPermitted(ref cause) => cause,
StartFleetError::ResourceNotFound(ref cause) => cause,
StartFleetError::Validation(ref cause) => cause,
StartFleetError::Credentials(ref err) => err.description(),
StartFleetError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StartFleetError::ParseError(ref cause) => cause,
StartFleetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartImageBuilderError {
ConcurrentModification(String),
IncompatibleImage(String),
InvalidAccountStatus(String),
ResourceNotAvailable(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartImageBuilderError {
pub fn from_response(res: BufferedHttpResponse) -> StartImageBuilderError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return StartImageBuilderError::ConcurrentModification(String::from(
error_message,
))
}
"IncompatibleImageException" => {
return StartImageBuilderError::IncompatibleImage(String::from(error_message))
}
"InvalidAccountStatusException" => {
return StartImageBuilderError::InvalidAccountStatus(String::from(error_message))
}
"ResourceNotAvailableException" => {
return StartImageBuilderError::ResourceNotAvailable(String::from(error_message))
}
"ResourceNotFoundException" => {
return StartImageBuilderError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return StartImageBuilderError::Validation(error_message.to_string())
}
_ => {}
}
}
return StartImageBuilderError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartImageBuilderError {
fn from(err: serde_json::error::Error) -> StartImageBuilderError {
StartImageBuilderError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartImageBuilderError {
fn from(err: CredentialsError) -> StartImageBuilderError {
StartImageBuilderError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartImageBuilderError {
fn from(err: HttpDispatchError) -> StartImageBuilderError {
StartImageBuilderError::HttpDispatch(err)
}
}
impl From<io::Error> for StartImageBuilderError {
fn from(err: io::Error) -> StartImageBuilderError {
StartImageBuilderError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartImageBuilderError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartImageBuilderError {
fn description(&self) -> &str {
match *self {
StartImageBuilderError::ConcurrentModification(ref cause) => cause,
StartImageBuilderError::IncompatibleImage(ref cause) => cause,
StartImageBuilderError::InvalidAccountStatus(ref cause) => cause,
StartImageBuilderError::ResourceNotAvailable(ref cause) => cause,
StartImageBuilderError::ResourceNotFound(ref cause) => cause,
StartImageBuilderError::Validation(ref cause) => cause,
StartImageBuilderError::Credentials(ref err) => err.description(),
StartImageBuilderError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
StartImageBuilderError::ParseError(ref cause) => cause,
StartImageBuilderError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StopFleetError {
ConcurrentModification(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StopFleetError {
pub fn from_response(res: BufferedHttpResponse) -> StopFleetError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return StopFleetError::ConcurrentModification(String::from(error_message))
}
"ResourceNotFoundException" => {
return StopFleetError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return StopFleetError::Validation(error_message.to_string())
}
_ => {}
}
}
return StopFleetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StopFleetError {
fn from(err: serde_json::error::Error) -> StopFleetError {
StopFleetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StopFleetError {
fn from(err: CredentialsError) -> StopFleetError {
StopFleetError::Credentials(err)
}
}
impl From<HttpDispatchError> for StopFleetError {
fn from(err: HttpDispatchError) -> StopFleetError {
StopFleetError::HttpDispatch(err)
}
}
impl From<io::Error> for StopFleetError {
fn from(err: io::Error) -> StopFleetError {
StopFleetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StopFleetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StopFleetError {
fn description(&self) -> &str {
match *self {
StopFleetError::ConcurrentModification(ref cause) => cause,
StopFleetError::ResourceNotFound(ref cause) => cause,
StopFleetError::Validation(ref cause) => cause,
StopFleetError::Credentials(ref err) => err.description(),
StopFleetError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StopFleetError::ParseError(ref cause) => cause,
StopFleetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StopImageBuilderError {
ConcurrentModification(String),
OperationNotPermitted(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StopImageBuilderError {
pub fn from_response(res: BufferedHttpResponse) -> StopImageBuilderError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return StopImageBuilderError::ConcurrentModification(String::from(
error_message,
))
}
"OperationNotPermittedException" => {
return StopImageBuilderError::OperationNotPermitted(String::from(error_message))
}
"ResourceNotFoundException" => {
return StopImageBuilderError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return StopImageBuilderError::Validation(error_message.to_string())
}
_ => {}
}
}
return StopImageBuilderError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StopImageBuilderError {
fn from(err: serde_json::error::Error) -> StopImageBuilderError {
StopImageBuilderError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StopImageBuilderError {
fn from(err: CredentialsError) -> StopImageBuilderError {
StopImageBuilderError::Credentials(err)
}
}
impl From<HttpDispatchError> for StopImageBuilderError {
fn from(err: HttpDispatchError) -> StopImageBuilderError {
StopImageBuilderError::HttpDispatch(err)
}
}
impl From<io::Error> for StopImageBuilderError {
fn from(err: io::Error) -> StopImageBuilderError {
StopImageBuilderError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StopImageBuilderError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StopImageBuilderError {
fn description(&self) -> &str {
match *self {
StopImageBuilderError::ConcurrentModification(ref cause) => cause,
StopImageBuilderError::OperationNotPermitted(ref cause) => cause,
StopImageBuilderError::ResourceNotFound(ref cause) => cause,
StopImageBuilderError::Validation(ref cause) => cause,
StopImageBuilderError::Credentials(ref err) => err.description(),
StopImageBuilderError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StopImageBuilderError::ParseError(ref cause) => cause,
StopImageBuilderError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InvalidAccountStatus(String),
LimitExceeded(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> TagResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidAccountStatusException" => {
return TagResourceError::InvalidAccountStatus(String::from(error_message))
}
"LimitExceededException" => {
return TagResourceError::LimitExceeded(String::from(error_message))
}
"ResourceNotFoundException" => {
return TagResourceError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return TagResourceError::Validation(error_message.to_string())
}
_ => {}
}
}
return TagResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for TagResourceError {
fn from(err: serde_json::error::Error) -> TagResourceError {
TagResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for TagResourceError {
fn from(err: CredentialsError) -> TagResourceError {
TagResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for TagResourceError {
fn from(err: HttpDispatchError) -> TagResourceError {
TagResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for TagResourceError {
fn from(err: io::Error) -> TagResourceError {
TagResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for TagResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for TagResourceError {
fn description(&self) -> &str {
match *self {
TagResourceError::InvalidAccountStatus(ref cause) => cause,
TagResourceError::LimitExceeded(ref cause) => cause,
TagResourceError::ResourceNotFound(ref cause) => cause,
TagResourceError::Validation(ref cause) => cause,
TagResourceError::Credentials(ref err) => err.description(),
TagResourceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
TagResourceError::ParseError(ref cause) => cause,
TagResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> UntagResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return UntagResourceError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return UntagResourceError::Validation(error_message.to_string())
}
_ => {}
}
}
return UntagResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UntagResourceError {
fn from(err: serde_json::error::Error) -> UntagResourceError {
UntagResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UntagResourceError {
fn from(err: CredentialsError) -> UntagResourceError {
UntagResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for UntagResourceError {
fn from(err: HttpDispatchError) -> UntagResourceError {
UntagResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for UntagResourceError {
fn from(err: io::Error) -> UntagResourceError {
UntagResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UntagResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UntagResourceError {
fn description(&self) -> &str {
match *self {
UntagResourceError::ResourceNotFound(ref cause) => cause,
UntagResourceError::Validation(ref cause) => cause,
UntagResourceError::Credentials(ref err) => err.description(),
UntagResourceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UntagResourceError::ParseError(ref cause) => cause,
UntagResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateDirectoryConfigError {
ConcurrentModification(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateDirectoryConfigError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateDirectoryConfigError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return UpdateDirectoryConfigError::ConcurrentModification(String::from(
error_message,
))
}
"ResourceInUseException" => {
return UpdateDirectoryConfigError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return UpdateDirectoryConfigError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return UpdateDirectoryConfigError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateDirectoryConfigError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateDirectoryConfigError {
fn from(err: serde_json::error::Error) -> UpdateDirectoryConfigError {
UpdateDirectoryConfigError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateDirectoryConfigError {
fn from(err: CredentialsError) -> UpdateDirectoryConfigError {
UpdateDirectoryConfigError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateDirectoryConfigError {
fn from(err: HttpDispatchError) -> UpdateDirectoryConfigError {
UpdateDirectoryConfigError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateDirectoryConfigError {
fn from(err: io::Error) -> UpdateDirectoryConfigError {
UpdateDirectoryConfigError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateDirectoryConfigError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateDirectoryConfigError {
fn description(&self) -> &str {
match *self {
UpdateDirectoryConfigError::ConcurrentModification(ref cause) => cause,
UpdateDirectoryConfigError::ResourceInUse(ref cause) => cause,
UpdateDirectoryConfigError::ResourceNotFound(ref cause) => cause,
UpdateDirectoryConfigError::Validation(ref cause) => cause,
UpdateDirectoryConfigError::Credentials(ref err) => err.description(),
UpdateDirectoryConfigError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateDirectoryConfigError::ParseError(ref cause) => cause,
UpdateDirectoryConfigError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateFleetError {
ConcurrentModification(String),
IncompatibleImage(String),
InvalidAccountStatus(String),
InvalidParameterCombination(String),
InvalidRole(String),
LimitExceeded(String),
OperationNotPermitted(String),
ResourceInUse(String),
ResourceNotAvailable(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateFleetError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateFleetError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return UpdateFleetError::ConcurrentModification(String::from(error_message))
}
"IncompatibleImageException" => {
return UpdateFleetError::IncompatibleImage(String::from(error_message))
}
"InvalidAccountStatusException" => {
return UpdateFleetError::InvalidAccountStatus(String::from(error_message))
}
"InvalidParameterCombinationException" => {
return UpdateFleetError::InvalidParameterCombination(String::from(
error_message,
))
}
"InvalidRoleException" => {
return UpdateFleetError::InvalidRole(String::from(error_message))
}
"LimitExceededException" => {
return UpdateFleetError::LimitExceeded(String::from(error_message))
}
"OperationNotPermittedException" => {
return UpdateFleetError::OperationNotPermitted(String::from(error_message))
}
"ResourceInUseException" => {
return UpdateFleetError::ResourceInUse(String::from(error_message))
}
"ResourceNotAvailableException" => {
return UpdateFleetError::ResourceNotAvailable(String::from(error_message))
}
"ResourceNotFoundException" => {
return UpdateFleetError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return UpdateFleetError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateFleetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateFleetError {
fn from(err: serde_json::error::Error) -> UpdateFleetError {
UpdateFleetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateFleetError {
fn from(err: CredentialsError) -> UpdateFleetError {
UpdateFleetError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateFleetError {
fn from(err: HttpDispatchError) -> UpdateFleetError {
UpdateFleetError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateFleetError {
fn from(err: io::Error) -> UpdateFleetError {
UpdateFleetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateFleetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateFleetError {
fn description(&self) -> &str {
match *self {
UpdateFleetError::ConcurrentModification(ref cause) => cause,
UpdateFleetError::IncompatibleImage(ref cause) => cause,
UpdateFleetError::InvalidAccountStatus(ref cause) => cause,
UpdateFleetError::InvalidParameterCombination(ref cause) => cause,
UpdateFleetError::InvalidRole(ref cause) => cause,
UpdateFleetError::LimitExceeded(ref cause) => cause,
UpdateFleetError::OperationNotPermitted(ref cause) => cause,
UpdateFleetError::ResourceInUse(ref cause) => cause,
UpdateFleetError::ResourceNotAvailable(ref cause) => cause,
UpdateFleetError::ResourceNotFound(ref cause) => cause,
UpdateFleetError::Validation(ref cause) => cause,
UpdateFleetError::Credentials(ref err) => err.description(),
UpdateFleetError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateFleetError::ParseError(ref cause) => cause,
UpdateFleetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateImagePermissionsError {
LimitExceeded(String),
ResourceNotAvailable(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateImagePermissionsError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateImagePermissionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"LimitExceededException" => {
return UpdateImagePermissionsError::LimitExceeded(String::from(error_message))
}
"ResourceNotAvailableException" => {
return UpdateImagePermissionsError::ResourceNotAvailable(String::from(
error_message,
))
}
"ResourceNotFoundException" => {
return UpdateImagePermissionsError::ResourceNotFound(String::from(
error_message,
))
}
"ValidationException" => {
return UpdateImagePermissionsError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateImagePermissionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateImagePermissionsError {
fn from(err: serde_json::error::Error) -> UpdateImagePermissionsError {
UpdateImagePermissionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateImagePermissionsError {
fn from(err: CredentialsError) -> UpdateImagePermissionsError {
UpdateImagePermissionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateImagePermissionsError {
fn from(err: HttpDispatchError) -> UpdateImagePermissionsError {
UpdateImagePermissionsError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateImagePermissionsError {
fn from(err: io::Error) -> UpdateImagePermissionsError {
UpdateImagePermissionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateImagePermissionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateImagePermissionsError {
fn description(&self) -> &str {
match *self {
UpdateImagePermissionsError::LimitExceeded(ref cause) => cause,
UpdateImagePermissionsError::ResourceNotAvailable(ref cause) => cause,
UpdateImagePermissionsError::ResourceNotFound(ref cause) => cause,
UpdateImagePermissionsError::Validation(ref cause) => cause,
UpdateImagePermissionsError::Credentials(ref err) => err.description(),
UpdateImagePermissionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateImagePermissionsError::ParseError(ref cause) => cause,
UpdateImagePermissionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateStackError {
IncompatibleImage(String),
InvalidAccountStatus(String),
InvalidParameterCombination(String),
InvalidRole(String),
LimitExceeded(String),
OperationNotPermitted(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateStackError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateStackError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"IncompatibleImageException" => {
return UpdateStackError::IncompatibleImage(String::from(error_message))
}
"InvalidAccountStatusException" => {
return UpdateStackError::InvalidAccountStatus(String::from(error_message))
}
"InvalidParameterCombinationException" => {
return UpdateStackError::InvalidParameterCombination(String::from(
error_message,
))
}
"InvalidRoleException" => {
return UpdateStackError::InvalidRole(String::from(error_message))
}
"LimitExceededException" => {
return UpdateStackError::LimitExceeded(String::from(error_message))
}
"OperationNotPermittedException" => {
return UpdateStackError::OperationNotPermitted(String::from(error_message))
}
"ResourceInUseException" => {
return UpdateStackError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return UpdateStackError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return UpdateStackError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateStackError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateStackError {
fn from(err: serde_json::error::Error) -> UpdateStackError {
UpdateStackError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateStackError {
fn from(err: CredentialsError) -> UpdateStackError {
UpdateStackError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateStackError {
fn from(err: HttpDispatchError) -> UpdateStackError {
UpdateStackError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateStackError {
fn from(err: io::Error) -> UpdateStackError {
UpdateStackError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateStackError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateStackError {
fn description(&self) -> &str {
match *self {
UpdateStackError::IncompatibleImage(ref cause) => cause,
UpdateStackError::InvalidAccountStatus(ref cause) => cause,
UpdateStackError::InvalidParameterCombination(ref cause) => cause,
UpdateStackError::InvalidRole(ref cause) => cause,
UpdateStackError::LimitExceeded(ref cause) => cause,
UpdateStackError::OperationNotPermitted(ref cause) => cause,
UpdateStackError::ResourceInUse(ref cause) => cause,
UpdateStackError::ResourceNotFound(ref cause) => cause,
UpdateStackError::Validation(ref cause) => cause,
UpdateStackError::Credentials(ref err) => err.description(),
UpdateStackError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateStackError::ParseError(ref cause) => cause,
UpdateStackError::Unknown(_) => "unknown error",
}
}
}
pub trait AppStream {
fn associate_fleet(
&self,
input: AssociateFleetRequest,
) -> RusotoFuture<AssociateFleetResult, AssociateFleetError>;
fn copy_image(
&self,
input: CopyImageRequest,
) -> RusotoFuture<CopyImageResponse, CopyImageError>;
fn create_directory_config(
&self,
input: CreateDirectoryConfigRequest,
) -> RusotoFuture<CreateDirectoryConfigResult, CreateDirectoryConfigError>;
fn create_fleet(
&self,
input: CreateFleetRequest,
) -> RusotoFuture<CreateFleetResult, CreateFleetError>;
fn create_image_builder(
&self,
input: CreateImageBuilderRequest,
) -> RusotoFuture<CreateImageBuilderResult, CreateImageBuilderError>;
fn create_image_builder_streaming_url(
&self,
input: CreateImageBuilderStreamingURLRequest,
) -> RusotoFuture<CreateImageBuilderStreamingURLResult, CreateImageBuilderStreamingURLError>;
fn create_stack(
&self,
input: CreateStackRequest,
) -> RusotoFuture<CreateStackResult, CreateStackError>;
fn create_streaming_url(
&self,
input: CreateStreamingURLRequest,
) -> RusotoFuture<CreateStreamingURLResult, CreateStreamingURLError>;
fn delete_directory_config(
&self,
input: DeleteDirectoryConfigRequest,
) -> RusotoFuture<DeleteDirectoryConfigResult, DeleteDirectoryConfigError>;
fn delete_fleet(
&self,
input: DeleteFleetRequest,
) -> RusotoFuture<DeleteFleetResult, DeleteFleetError>;
fn delete_image(
&self,
input: DeleteImageRequest,
) -> RusotoFuture<DeleteImageResult, DeleteImageError>;
fn delete_image_builder(
&self,
input: DeleteImageBuilderRequest,
) -> RusotoFuture<DeleteImageBuilderResult, DeleteImageBuilderError>;
fn delete_image_permissions(
&self,
input: DeleteImagePermissionsRequest,
) -> RusotoFuture<DeleteImagePermissionsResult, DeleteImagePermissionsError>;
fn delete_stack(
&self,
input: DeleteStackRequest,
) -> RusotoFuture<DeleteStackResult, DeleteStackError>;
fn describe_directory_configs(
&self,
input: DescribeDirectoryConfigsRequest,
) -> RusotoFuture<DescribeDirectoryConfigsResult, DescribeDirectoryConfigsError>;
fn describe_fleets(
&self,
input: DescribeFleetsRequest,
) -> RusotoFuture<DescribeFleetsResult, DescribeFleetsError>;
fn describe_image_builders(
&self,
input: DescribeImageBuildersRequest,
) -> RusotoFuture<DescribeImageBuildersResult, DescribeImageBuildersError>;
fn describe_image_permissions(
&self,
input: DescribeImagePermissionsRequest,
) -> RusotoFuture<DescribeImagePermissionsResult, DescribeImagePermissionsError>;
fn describe_images(
&self,
input: DescribeImagesRequest,
) -> RusotoFuture<DescribeImagesResult, DescribeImagesError>;
fn describe_sessions(
&self,
input: DescribeSessionsRequest,
) -> RusotoFuture<DescribeSessionsResult, DescribeSessionsError>;
fn describe_stacks(
&self,
input: DescribeStacksRequest,
) -> RusotoFuture<DescribeStacksResult, DescribeStacksError>;
fn disassociate_fleet(
&self,
input: DisassociateFleetRequest,
) -> RusotoFuture<DisassociateFleetResult, DisassociateFleetError>;
fn expire_session(
&self,
input: ExpireSessionRequest,
) -> RusotoFuture<ExpireSessionResult, ExpireSessionError>;
fn list_associated_fleets(
&self,
input: ListAssociatedFleetsRequest,
) -> RusotoFuture<ListAssociatedFleetsResult, ListAssociatedFleetsError>;
fn list_associated_stacks(
&self,
input: ListAssociatedStacksRequest,
) -> RusotoFuture<ListAssociatedStacksResult, ListAssociatedStacksError>;
fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> RusotoFuture<ListTagsForResourceResponse, ListTagsForResourceError>;
fn start_fleet(
&self,
input: StartFleetRequest,
) -> RusotoFuture<StartFleetResult, StartFleetError>;
fn start_image_builder(
&self,
input: StartImageBuilderRequest,
) -> RusotoFuture<StartImageBuilderResult, StartImageBuilderError>;
fn stop_fleet(&self, input: StopFleetRequest) -> RusotoFuture<StopFleetResult, StopFleetError>;
fn stop_image_builder(
&self,
input: StopImageBuilderRequest,
) -> RusotoFuture<StopImageBuilderResult, StopImageBuilderError>;
fn tag_resource(
&self,
input: TagResourceRequest,
) -> RusotoFuture<TagResourceResponse, TagResourceError>;
fn untag_resource(
&self,
input: UntagResourceRequest,
) -> RusotoFuture<UntagResourceResponse, UntagResourceError>;
fn update_directory_config(
&self,
input: UpdateDirectoryConfigRequest,
) -> RusotoFuture<UpdateDirectoryConfigResult, UpdateDirectoryConfigError>;
fn update_fleet(
&self,
input: UpdateFleetRequest,
) -> RusotoFuture<UpdateFleetResult, UpdateFleetError>;
fn update_image_permissions(
&self,
input: UpdateImagePermissionsRequest,
) -> RusotoFuture<UpdateImagePermissionsResult, UpdateImagePermissionsError>;
fn update_stack(
&self,
input: UpdateStackRequest,
) -> RusotoFuture<UpdateStackResult, UpdateStackError>;
}
pub struct AppStreamClient {
client: Client,
region: region::Region,
}
impl AppStreamClient {
pub fn new(region: region::Region) -> AppStreamClient {
AppStreamClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> AppStreamClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
AppStreamClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl AppStream for AppStreamClient {
fn associate_fleet(
&self,
input: AssociateFleetRequest,
) -> RusotoFuture<AssociateFleetResult, AssociateFleetError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.AssociateFleet");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<AssociateFleetResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(AssociateFleetError::from_response(response))),
)
}
})
}
fn copy_image(
&self,
input: CopyImageRequest,
) -> RusotoFuture<CopyImageResponse, CopyImageError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.CopyImage");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CopyImageResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CopyImageError::from_response(response))),
)
}
})
}
fn create_directory_config(
&self,
input: CreateDirectoryConfigRequest,
) -> RusotoFuture<CreateDirectoryConfigResult, CreateDirectoryConfigError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"PhotonAdminProxyService.CreateDirectoryConfig",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateDirectoryConfigResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateDirectoryConfigError::from_response(response))
}),
)
}
})
}
fn create_fleet(
&self,
input: CreateFleetRequest,
) -> RusotoFuture<CreateFleetResult, CreateFleetError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.CreateFleet");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateFleetResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateFleetError::from_response(response))),
)
}
})
}
fn create_image_builder(
&self,
input: CreateImageBuilderRequest,
) -> RusotoFuture<CreateImageBuilderResult, CreateImageBuilderError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.CreateImageBuilder");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateImageBuilderResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateImageBuilderError::from_response(response))),
)
}
})
}
fn create_image_builder_streaming_url(
&self,
input: CreateImageBuilderStreamingURLRequest,
) -> RusotoFuture<CreateImageBuilderStreamingURLResult, CreateImageBuilderStreamingURLError>
{
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"PhotonAdminProxyService.CreateImageBuilderStreamingURL",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateImageBuilderStreamingURLResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateImageBuilderStreamingURLError::from_response(response))
}))
}
})
}
fn create_stack(
&self,
input: CreateStackRequest,
) -> RusotoFuture<CreateStackResult, CreateStackError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.CreateStack");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateStackResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateStackError::from_response(response))),
)
}
})
}
fn create_streaming_url(
&self,
input: CreateStreamingURLRequest,
) -> RusotoFuture<CreateStreamingURLResult, CreateStreamingURLError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.CreateStreamingURL");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateStreamingURLResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateStreamingURLError::from_response(response))),
)
}
})
}
fn delete_directory_config(
&self,
input: DeleteDirectoryConfigRequest,
) -> RusotoFuture<DeleteDirectoryConfigResult, DeleteDirectoryConfigError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"PhotonAdminProxyService.DeleteDirectoryConfig",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteDirectoryConfigResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteDirectoryConfigError::from_response(response))
}),
)
}
})
}
fn delete_fleet(
&self,
input: DeleteFleetRequest,
) -> RusotoFuture<DeleteFleetResult, DeleteFleetError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.DeleteFleet");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteFleetResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteFleetError::from_response(response))),
)
}
})
}
fn delete_image(
&self,
input: DeleteImageRequest,
) -> RusotoFuture<DeleteImageResult, DeleteImageError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.DeleteImage");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteImageResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteImageError::from_response(response))),
)
}
})
}
fn delete_image_builder(
&self,
input: DeleteImageBuilderRequest,
) -> RusotoFuture<DeleteImageBuilderResult, DeleteImageBuilderError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.DeleteImageBuilder");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteImageBuilderResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteImageBuilderError::from_response(response))),
)
}
})
}
fn delete_image_permissions(
&self,
input: DeleteImagePermissionsRequest,
) -> RusotoFuture<DeleteImagePermissionsResult, DeleteImagePermissionsError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"PhotonAdminProxyService.DeleteImagePermissions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteImagePermissionsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteImagePermissionsError::from_response(response))
}),
)
}
})
}
fn delete_stack(
&self,
input: DeleteStackRequest,
) -> RusotoFuture<DeleteStackResult, DeleteStackError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.DeleteStack");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteStackResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteStackError::from_response(response))),
)
}
})
}
fn describe_directory_configs(
&self,
input: DescribeDirectoryConfigsRequest,
) -> RusotoFuture<DescribeDirectoryConfigsResult, DescribeDirectoryConfigsError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"PhotonAdminProxyService.DescribeDirectoryConfigs",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeDirectoryConfigsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeDirectoryConfigsError::from_response(response))
}))
}
})
}
fn describe_fleets(
&self,
input: DescribeFleetsRequest,
) -> RusotoFuture<DescribeFleetsResult, DescribeFleetsError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.DescribeFleets");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeFleetsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeFleetsError::from_response(response))),
)
}
})
}
fn describe_image_builders(
&self,
input: DescribeImageBuildersRequest,
) -> RusotoFuture<DescribeImageBuildersResult, DescribeImageBuildersError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"PhotonAdminProxyService.DescribeImageBuilders",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeImageBuildersResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeImageBuildersError::from_response(response))
}),
)
}
})
}
fn describe_image_permissions(
&self,
input: DescribeImagePermissionsRequest,
) -> RusotoFuture<DescribeImagePermissionsResult, DescribeImagePermissionsError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"PhotonAdminProxyService.DescribeImagePermissions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeImagePermissionsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeImagePermissionsError::from_response(response))
}))
}
})
}
fn describe_images(
&self,
input: DescribeImagesRequest,
) -> RusotoFuture<DescribeImagesResult, DescribeImagesError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.DescribeImages");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeImagesResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeImagesError::from_response(response))),
)
}
})
}
fn describe_sessions(
&self,
input: DescribeSessionsRequest,
) -> RusotoFuture<DescribeSessionsResult, DescribeSessionsError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.DescribeSessions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeSessionsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeSessionsError::from_response(response))),
)
}
})
}
fn describe_stacks(
&self,
input: DescribeStacksRequest,
) -> RusotoFuture<DescribeStacksResult, DescribeStacksError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.DescribeStacks");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeStacksResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeStacksError::from_response(response))),
)
}
})
}
fn disassociate_fleet(
&self,
input: DisassociateFleetRequest,
) -> RusotoFuture<DisassociateFleetResult, DisassociateFleetError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.DisassociateFleet");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DisassociateFleetResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DisassociateFleetError::from_response(response))),
)
}
})
}
fn expire_session(
&self,
input: ExpireSessionRequest,
) -> RusotoFuture<ExpireSessionResult, ExpireSessionError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.ExpireSession");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ExpireSessionResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ExpireSessionError::from_response(response))),
)
}
})
}
fn list_associated_fleets(
&self,
input: ListAssociatedFleetsRequest,
) -> RusotoFuture<ListAssociatedFleetsResult, ListAssociatedFleetsError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"PhotonAdminProxyService.ListAssociatedFleets",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListAssociatedFleetsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListAssociatedFleetsError::from_response(response))
}),
)
}
})
}
fn list_associated_stacks(
&self,
input: ListAssociatedStacksRequest,
) -> RusotoFuture<ListAssociatedStacksResult, ListAssociatedStacksError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"PhotonAdminProxyService.ListAssociatedStacks",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListAssociatedStacksResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListAssociatedStacksError::from_response(response))
}),
)
}
})
}
fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> RusotoFuture<ListTagsForResourceResponse, ListTagsForResourceError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"PhotonAdminProxyService.ListTagsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListTagsForResourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListTagsForResourceError::from_response(response))
}),
)
}
})
}
fn start_fleet(
&self,
input: StartFleetRequest,
) -> RusotoFuture<StartFleetResult, StartFleetError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.StartFleet");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<StartFleetResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StartFleetError::from_response(response))),
)
}
})
}
fn start_image_builder(
&self,
input: StartImageBuilderRequest,
) -> RusotoFuture<StartImageBuilderResult, StartImageBuilderError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.StartImageBuilder");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<StartImageBuilderResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StartImageBuilderError::from_response(response))),
)
}
})
}
fn stop_fleet(&self, input: StopFleetRequest) -> RusotoFuture<StopFleetResult, StopFleetError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.StopFleet");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<StopFleetResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StopFleetError::from_response(response))),
)
}
})
}
fn stop_image_builder(
&self,
input: StopImageBuilderRequest,
) -> RusotoFuture<StopImageBuilderResult, StopImageBuilderError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.StopImageBuilder");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<StopImageBuilderResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StopImageBuilderError::from_response(response))),
)
}
})
}
fn tag_resource(
&self,
input: TagResourceRequest,
) -> RusotoFuture<TagResourceResponse, TagResourceError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<TagResourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(TagResourceError::from_response(response))),
)
}
})
}
fn untag_resource(
&self,
input: UntagResourceRequest,
) -> RusotoFuture<UntagResourceResponse, UntagResourceError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<UntagResourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UntagResourceError::from_response(response))),
)
}
})
}
fn update_directory_config(
&self,
input: UpdateDirectoryConfigRequest,
) -> RusotoFuture<UpdateDirectoryConfigResult, UpdateDirectoryConfigError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"PhotonAdminProxyService.UpdateDirectoryConfig",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<UpdateDirectoryConfigResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(UpdateDirectoryConfigError::from_response(response))
}),
)
}
})
}
fn update_fleet(
&self,
input: UpdateFleetRequest,
) -> RusotoFuture<UpdateFleetResult, UpdateFleetError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.UpdateFleet");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<UpdateFleetResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateFleetError::from_response(response))),
)
}
})
}
fn update_image_permissions(
&self,
input: UpdateImagePermissionsRequest,
) -> RusotoFuture<UpdateImagePermissionsResult, UpdateImagePermissionsError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"PhotonAdminProxyService.UpdateImagePermissions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<UpdateImagePermissionsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(UpdateImagePermissionsError::from_response(response))
}),
)
}
})
}
fn update_stack(
&self,
input: UpdateStackRequest,
) -> RusotoFuture<UpdateStackResult, UpdateStackError> {
let mut request = SignedRequest::new("POST", "appstream", &self.region, "/");
request.set_endpoint_prefix("appstream2".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "PhotonAdminProxyService.UpdateStack");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<UpdateStackResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateStackError::from_response(response))),
)
}
})
}
}
#[cfg(test)]
mod protocol_tests {}