use std::error::Error;
use std::fmt;
use std::io;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoFuture};
use rusoto_core::credential::{CredentialsError, ProvideAwsCredentials};
use rusoto_core::request::HttpDispatchError;
use rusoto_core::signature::SignedRequest;
use serde_json;
use serde_json::from_slice;
use serde_json::Value as SerdeJsonValue;
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Address {
#[serde(rename = "AddressId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_id: Option<String>,
#[serde(rename = "City")]
#[serde(skip_serializing_if = "Option::is_none")]
pub city: Option<String>,
#[serde(rename = "Company")]
#[serde(skip_serializing_if = "Option::is_none")]
pub company: Option<String>,
#[serde(rename = "Country")]
#[serde(skip_serializing_if = "Option::is_none")]
pub country: Option<String>,
#[serde(rename = "IsRestricted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_restricted: Option<bool>,
#[serde(rename = "Landmark")]
#[serde(skip_serializing_if = "Option::is_none")]
pub landmark: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "PhoneNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_number: Option<String>,
#[serde(rename = "PostalCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub postal_code: Option<String>,
#[serde(rename = "PrefectureOrDistrict")]
#[serde(skip_serializing_if = "Option::is_none")]
pub prefecture_or_district: Option<String>,
#[serde(rename = "StateOrProvince")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_or_province: Option<String>,
#[serde(rename = "Street1")]
#[serde(skip_serializing_if = "Option::is_none")]
pub street_1: Option<String>,
#[serde(rename = "Street2")]
#[serde(skip_serializing_if = "Option::is_none")]
pub street_2: Option<String>,
#[serde(rename = "Street3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub street_3: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CancelClusterRequest {
#[serde(rename = "ClusterId")]
pub cluster_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CancelClusterResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CancelJobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CancelJobResult {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ClusterListEntry {
#[serde(rename = "ClusterId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cluster_id: Option<String>,
#[serde(rename = "ClusterState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cluster_state: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ClusterMetadata {
#[serde(rename = "AddressId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_id: Option<String>,
#[serde(rename = "ClusterId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cluster_id: Option<String>,
#[serde(rename = "ClusterState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cluster_state: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ForwardingAddressId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub forwarding_address_id: Option<String>,
#[serde(rename = "JobType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_type: Option<String>,
#[serde(rename = "KmsKeyARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_arn: Option<String>,
#[serde(rename = "Notification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification: Option<Notification>,
#[serde(rename = "Resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<JobResource>,
#[serde(rename = "RoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "ShippingOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_option: Option<String>,
#[serde(rename = "SnowballType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snowball_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CompatibleImage {
#[serde(rename = "AmiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ami_id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateAddressRequest {
#[serde(rename = "Address")]
pub address: Address,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateAddressResult {
#[serde(rename = "AddressId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateClusterRequest {
#[serde(rename = "AddressId")]
pub address_id: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ForwardingAddressId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub forwarding_address_id: Option<String>,
#[serde(rename = "JobType")]
pub job_type: String,
#[serde(rename = "KmsKeyARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_arn: Option<String>,
#[serde(rename = "Notification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification: Option<Notification>,
#[serde(rename = "Resources")]
pub resources: JobResource,
#[serde(rename = "RoleARN")]
pub role_arn: String,
#[serde(rename = "ShippingOption")]
pub shipping_option: String,
#[serde(rename = "SnowballType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snowball_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateClusterResult {
#[serde(rename = "ClusterId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cluster_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateJobRequest {
#[serde(rename = "AddressId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_id: Option<String>,
#[serde(rename = "ClusterId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cluster_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ForwardingAddressId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub forwarding_address_id: Option<String>,
#[serde(rename = "JobType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_type: Option<String>,
#[serde(rename = "KmsKeyARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_arn: Option<String>,
#[serde(rename = "Notification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification: Option<Notification>,
#[serde(rename = "Resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<JobResource>,
#[serde(rename = "RoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "ShippingOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_option: Option<String>,
#[serde(rename = "SnowballCapacityPreference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snowball_capacity_preference: Option<String>,
#[serde(rename = "SnowballType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snowball_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateJobResult {
#[serde(rename = "JobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DataTransfer {
#[serde(rename = "BytesTransferred")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bytes_transferred: Option<i64>,
#[serde(rename = "ObjectsTransferred")]
#[serde(skip_serializing_if = "Option::is_none")]
pub objects_transferred: Option<i64>,
#[serde(rename = "TotalBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_bytes: Option<i64>,
#[serde(rename = "TotalObjects")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_objects: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeAddressRequest {
#[serde(rename = "AddressId")]
pub address_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeAddressResult {
#[serde(rename = "Address")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address: Option<Address>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeAddressesRequest {
#[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 DescribeAddressesResult {
#[serde(rename = "Addresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub addresses: Option<Vec<Address>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeClusterRequest {
#[serde(rename = "ClusterId")]
pub cluster_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeClusterResult {
#[serde(rename = "ClusterMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cluster_metadata: Option<ClusterMetadata>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeJobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeJobResult {
#[serde(rename = "JobMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_metadata: Option<JobMetadata>,
#[serde(rename = "SubJobMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sub_job_metadata: Option<Vec<JobMetadata>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Ec2AmiResource {
#[serde(rename = "AmiId")]
pub ami_id: String,
#[serde(rename = "SnowballAmiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snowball_ami_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EventTriggerDefinition {
#[serde(rename = "EventResourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_resource_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetJobManifestRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetJobManifestResult {
#[serde(rename = "ManifestURI")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_uri: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetJobUnlockCodeRequest {
#[serde(rename = "JobId")]
pub job_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetJobUnlockCodeResult {
#[serde(rename = "UnlockCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unlock_code: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetSnowballUsageRequest {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetSnowballUsageResult {
#[serde(rename = "SnowballLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snowball_limit: Option<i64>,
#[serde(rename = "SnowballsInUse")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snowballs_in_use: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct JobListEntry {
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "IsMaster")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_master: Option<bool>,
#[serde(rename = "JobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
#[serde(rename = "JobState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_state: Option<String>,
#[serde(rename = "JobType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_type: Option<String>,
#[serde(rename = "SnowballType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snowball_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct JobLogs {
#[serde(rename = "JobCompletionReportURI")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_completion_report_uri: Option<String>,
#[serde(rename = "JobFailureLogURI")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_failure_log_uri: Option<String>,
#[serde(rename = "JobSuccessLogURI")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_success_log_uri: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct JobMetadata {
#[serde(rename = "AddressId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_id: Option<String>,
#[serde(rename = "ClusterId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cluster_id: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "DataTransferProgress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_transfer_progress: Option<DataTransfer>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ForwardingAddressId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub forwarding_address_id: Option<String>,
#[serde(rename = "JobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
#[serde(rename = "JobLogInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_log_info: Option<JobLogs>,
#[serde(rename = "JobState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_state: Option<String>,
#[serde(rename = "JobType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_type: Option<String>,
#[serde(rename = "KmsKeyARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_arn: Option<String>,
#[serde(rename = "Notification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification: Option<Notification>,
#[serde(rename = "Resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<JobResource>,
#[serde(rename = "RoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "ShippingDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_details: Option<ShippingDetails>,
#[serde(rename = "SnowballCapacityPreference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snowball_capacity_preference: Option<String>,
#[serde(rename = "SnowballType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snowball_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct JobResource {
#[serde(rename = "Ec2AmiResources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_ami_resources: Option<Vec<Ec2AmiResource>>,
#[serde(rename = "LambdaResources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_resources: Option<Vec<LambdaResource>>,
#[serde(rename = "S3Resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_resources: Option<Vec<S3Resource>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct KeyRange {
#[serde(rename = "BeginMarker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub begin_marker: Option<String>,
#[serde(rename = "EndMarker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LambdaResource {
#[serde(rename = "EventTriggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_triggers: Option<Vec<EventTriggerDefinition>>,
#[serde(rename = "LambdaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListClusterJobsRequest {
#[serde(rename = "ClusterId")]
pub cluster_id: 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 ListClusterJobsResult {
#[serde(rename = "JobListEntries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_list_entries: Option<Vec<JobListEntry>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListClustersRequest {
#[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 ListClustersResult {
#[serde(rename = "ClusterListEntries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cluster_list_entries: Option<Vec<ClusterListEntry>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListCompatibleImagesRequest {
#[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 ListCompatibleImagesResult {
#[serde(rename = "CompatibleImages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible_images: Option<Vec<CompatibleImage>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListJobsRequest {
#[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 ListJobsResult {
#[serde(rename = "JobListEntries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_list_entries: Option<Vec<JobListEntry>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Notification {
#[serde(rename = "JobStatesToNotify")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_states_to_notify: Option<Vec<String>>,
#[serde(rename = "NotifyAll")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notify_all: Option<bool>,
#[serde(rename = "SnsTopicARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_topic_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct S3Resource {
#[serde(rename = "BucketArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket_arn: Option<String>,
#[serde(rename = "KeyRange")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_range: Option<KeyRange>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Shipment {
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "TrackingNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracking_number: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ShippingDetails {
#[serde(rename = "InboundShipment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inbound_shipment: Option<Shipment>,
#[serde(rename = "OutboundShipment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub outbound_shipment: Option<Shipment>,
#[serde(rename = "ShippingOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_option: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateClusterRequest {
#[serde(rename = "AddressId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_id: Option<String>,
#[serde(rename = "ClusterId")]
pub cluster_id: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ForwardingAddressId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub forwarding_address_id: Option<String>,
#[serde(rename = "Notification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification: Option<Notification>,
#[serde(rename = "Resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<JobResource>,
#[serde(rename = "RoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "ShippingOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_option: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateClusterResult {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateJobRequest {
#[serde(rename = "AddressId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ForwardingAddressId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub forwarding_address_id: Option<String>,
#[serde(rename = "JobId")]
pub job_id: String,
#[serde(rename = "Notification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification: Option<Notification>,
#[serde(rename = "Resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<JobResource>,
#[serde(rename = "RoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "ShippingOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_option: Option<String>,
#[serde(rename = "SnowballCapacityPreference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snowball_capacity_preference: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateJobResult {}
#[derive(Debug, PartialEq)]
pub enum CancelClusterError {
InvalidJobState(String),
InvalidResource(String),
KMSRequestFailed(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CancelClusterError {
pub fn from_response(res: BufferedHttpResponse) -> CancelClusterError {
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 {
"InvalidJobStateException" => {
return CancelClusterError::InvalidJobState(String::from(error_message));
}
"InvalidResourceException" => {
return CancelClusterError::InvalidResource(String::from(error_message));
}
"KMSRequestFailedException" => {
return CancelClusterError::KMSRequestFailed(String::from(error_message));
}
"ValidationException" => {
return CancelClusterError::Validation(error_message.to_string());
}
_ => {}
}
}
return CancelClusterError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CancelClusterError {
fn from(err: serde_json::error::Error) -> CancelClusterError {
CancelClusterError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CancelClusterError {
fn from(err: CredentialsError) -> CancelClusterError {
CancelClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for CancelClusterError {
fn from(err: HttpDispatchError) -> CancelClusterError {
CancelClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for CancelClusterError {
fn from(err: io::Error) -> CancelClusterError {
CancelClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CancelClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CancelClusterError {
fn description(&self) -> &str {
match *self {
CancelClusterError::InvalidJobState(ref cause) => cause,
CancelClusterError::InvalidResource(ref cause) => cause,
CancelClusterError::KMSRequestFailed(ref cause) => cause,
CancelClusterError::Validation(ref cause) => cause,
CancelClusterError::Credentials(ref err) => err.description(),
CancelClusterError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CancelClusterError::ParseError(ref cause) => cause,
CancelClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CancelJobError {
InvalidJobState(String),
InvalidResource(String),
KMSRequestFailed(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CancelJobError {
pub fn from_response(res: BufferedHttpResponse) -> CancelJobError {
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 {
"InvalidJobStateException" => {
return CancelJobError::InvalidJobState(String::from(error_message));
}
"InvalidResourceException" => {
return CancelJobError::InvalidResource(String::from(error_message));
}
"KMSRequestFailedException" => {
return CancelJobError::KMSRequestFailed(String::from(error_message));
}
"ValidationException" => {
return CancelJobError::Validation(error_message.to_string());
}
_ => {}
}
}
return CancelJobError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CancelJobError {
fn from(err: serde_json::error::Error) -> CancelJobError {
CancelJobError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CancelJobError {
fn from(err: CredentialsError) -> CancelJobError {
CancelJobError::Credentials(err)
}
}
impl From<HttpDispatchError> for CancelJobError {
fn from(err: HttpDispatchError) -> CancelJobError {
CancelJobError::HttpDispatch(err)
}
}
impl From<io::Error> for CancelJobError {
fn from(err: io::Error) -> CancelJobError {
CancelJobError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CancelJobError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CancelJobError {
fn description(&self) -> &str {
match *self {
CancelJobError::InvalidJobState(ref cause) => cause,
CancelJobError::InvalidResource(ref cause) => cause,
CancelJobError::KMSRequestFailed(ref cause) => cause,
CancelJobError::Validation(ref cause) => cause,
CancelJobError::Credentials(ref err) => err.description(),
CancelJobError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CancelJobError::ParseError(ref cause) => cause,
CancelJobError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateAddressError {
InvalidAddress(String),
UnsupportedAddress(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateAddressError {
pub fn from_response(res: BufferedHttpResponse) -> CreateAddressError {
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 {
"InvalidAddressException" => {
return CreateAddressError::InvalidAddress(String::from(error_message));
}
"UnsupportedAddressException" => {
return CreateAddressError::UnsupportedAddress(String::from(error_message));
}
"ValidationException" => {
return CreateAddressError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateAddressError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateAddressError {
fn from(err: serde_json::error::Error) -> CreateAddressError {
CreateAddressError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateAddressError {
fn from(err: CredentialsError) -> CreateAddressError {
CreateAddressError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateAddressError {
fn from(err: HttpDispatchError) -> CreateAddressError {
CreateAddressError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateAddressError {
fn from(err: io::Error) -> CreateAddressError {
CreateAddressError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateAddressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateAddressError {
fn description(&self) -> &str {
match *self {
CreateAddressError::InvalidAddress(ref cause) => cause,
CreateAddressError::UnsupportedAddress(ref cause) => cause,
CreateAddressError::Validation(ref cause) => cause,
CreateAddressError::Credentials(ref err) => err.description(),
CreateAddressError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateAddressError::ParseError(ref cause) => cause,
CreateAddressError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateClusterError {
Ec2RequestFailed(String),
InvalidInputCombination(String),
InvalidResource(String),
KMSRequestFailed(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateClusterError {
pub fn from_response(res: BufferedHttpResponse) -> CreateClusterError {
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 {
"Ec2RequestFailedException" => {
return CreateClusterError::Ec2RequestFailed(String::from(error_message));
}
"InvalidInputCombinationException" => {
return CreateClusterError::InvalidInputCombination(String::from(error_message));
}
"InvalidResourceException" => {
return CreateClusterError::InvalidResource(String::from(error_message));
}
"KMSRequestFailedException" => {
return CreateClusterError::KMSRequestFailed(String::from(error_message));
}
"ValidationException" => {
return CreateClusterError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateClusterError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateClusterError {
fn from(err: serde_json::error::Error) -> CreateClusterError {
CreateClusterError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateClusterError {
fn from(err: CredentialsError) -> CreateClusterError {
CreateClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateClusterError {
fn from(err: HttpDispatchError) -> CreateClusterError {
CreateClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateClusterError {
fn from(err: io::Error) -> CreateClusterError {
CreateClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateClusterError {
fn description(&self) -> &str {
match *self {
CreateClusterError::Ec2RequestFailed(ref cause) => cause,
CreateClusterError::InvalidInputCombination(ref cause) => cause,
CreateClusterError::InvalidResource(ref cause) => cause,
CreateClusterError::KMSRequestFailed(ref cause) => cause,
CreateClusterError::Validation(ref cause) => cause,
CreateClusterError::Credentials(ref err) => err.description(),
CreateClusterError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateClusterError::ParseError(ref cause) => cause,
CreateClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateJobError {
ClusterLimitExceeded(String),
Ec2RequestFailed(String),
InvalidInputCombination(String),
InvalidResource(String),
KMSRequestFailed(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateJobError {
pub fn from_response(res: BufferedHttpResponse) -> CreateJobError {
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 {
"ClusterLimitExceededException" => {
return CreateJobError::ClusterLimitExceeded(String::from(error_message));
}
"Ec2RequestFailedException" => {
return CreateJobError::Ec2RequestFailed(String::from(error_message));
}
"InvalidInputCombinationException" => {
return CreateJobError::InvalidInputCombination(String::from(error_message));
}
"InvalidResourceException" => {
return CreateJobError::InvalidResource(String::from(error_message));
}
"KMSRequestFailedException" => {
return CreateJobError::KMSRequestFailed(String::from(error_message));
}
"ValidationException" => {
return CreateJobError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateJobError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateJobError {
fn from(err: serde_json::error::Error) -> CreateJobError {
CreateJobError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateJobError {
fn from(err: CredentialsError) -> CreateJobError {
CreateJobError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateJobError {
fn from(err: HttpDispatchError) -> CreateJobError {
CreateJobError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateJobError {
fn from(err: io::Error) -> CreateJobError {
CreateJobError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateJobError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateJobError {
fn description(&self) -> &str {
match *self {
CreateJobError::ClusterLimitExceeded(ref cause) => cause,
CreateJobError::Ec2RequestFailed(ref cause) => cause,
CreateJobError::InvalidInputCombination(ref cause) => cause,
CreateJobError::InvalidResource(ref cause) => cause,
CreateJobError::KMSRequestFailed(ref cause) => cause,
CreateJobError::Validation(ref cause) => cause,
CreateJobError::Credentials(ref err) => err.description(),
CreateJobError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateJobError::ParseError(ref cause) => cause,
CreateJobError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAddressError {
InvalidResource(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAddressError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAddressError {
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 {
"InvalidResourceException" => {
return DescribeAddressError::InvalidResource(String::from(error_message));
}
"ValidationException" => {
return DescribeAddressError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeAddressError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeAddressError {
fn from(err: serde_json::error::Error) -> DescribeAddressError {
DescribeAddressError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeAddressError {
fn from(err: CredentialsError) -> DescribeAddressError {
DescribeAddressError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAddressError {
fn from(err: HttpDispatchError) -> DescribeAddressError {
DescribeAddressError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAddressError {
fn from(err: io::Error) -> DescribeAddressError {
DescribeAddressError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAddressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAddressError {
fn description(&self) -> &str {
match *self {
DescribeAddressError::InvalidResource(ref cause) => cause,
DescribeAddressError::Validation(ref cause) => cause,
DescribeAddressError::Credentials(ref err) => err.description(),
DescribeAddressError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeAddressError::ParseError(ref cause) => cause,
DescribeAddressError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAddressesError {
InvalidNextToken(String),
InvalidResource(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAddressesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAddressesError {
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 {
"InvalidNextTokenException" => {
return DescribeAddressesError::InvalidNextToken(String::from(error_message));
}
"InvalidResourceException" => {
return DescribeAddressesError::InvalidResource(String::from(error_message));
}
"ValidationException" => {
return DescribeAddressesError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeAddressesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeAddressesError {
fn from(err: serde_json::error::Error) -> DescribeAddressesError {
DescribeAddressesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeAddressesError {
fn from(err: CredentialsError) -> DescribeAddressesError {
DescribeAddressesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAddressesError {
fn from(err: HttpDispatchError) -> DescribeAddressesError {
DescribeAddressesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAddressesError {
fn from(err: io::Error) -> DescribeAddressesError {
DescribeAddressesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAddressesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAddressesError {
fn description(&self) -> &str {
match *self {
DescribeAddressesError::InvalidNextToken(ref cause) => cause,
DescribeAddressesError::InvalidResource(ref cause) => cause,
DescribeAddressesError::Validation(ref cause) => cause,
DescribeAddressesError::Credentials(ref err) => err.description(),
DescribeAddressesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAddressesError::ParseError(ref cause) => cause,
DescribeAddressesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeClusterError {
InvalidResource(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeClusterError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeClusterError {
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 {
"InvalidResourceException" => {
return DescribeClusterError::InvalidResource(String::from(error_message));
}
"ValidationException" => {
return DescribeClusterError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeClusterError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeClusterError {
fn from(err: serde_json::error::Error) -> DescribeClusterError {
DescribeClusterError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeClusterError {
fn from(err: CredentialsError) -> DescribeClusterError {
DescribeClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeClusterError {
fn from(err: HttpDispatchError) -> DescribeClusterError {
DescribeClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeClusterError {
fn from(err: io::Error) -> DescribeClusterError {
DescribeClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeClusterError {
fn description(&self) -> &str {
match *self {
DescribeClusterError::InvalidResource(ref cause) => cause,
DescribeClusterError::Validation(ref cause) => cause,
DescribeClusterError::Credentials(ref err) => err.description(),
DescribeClusterError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeClusterError::ParseError(ref cause) => cause,
DescribeClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeJobError {
InvalidResource(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeJobError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeJobError {
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 {
"InvalidResourceException" => {
return DescribeJobError::InvalidResource(String::from(error_message));
}
"ValidationException" => {
return DescribeJobError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeJobError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeJobError {
fn from(err: serde_json::error::Error) -> DescribeJobError {
DescribeJobError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeJobError {
fn from(err: CredentialsError) -> DescribeJobError {
DescribeJobError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeJobError {
fn from(err: HttpDispatchError) -> DescribeJobError {
DescribeJobError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeJobError {
fn from(err: io::Error) -> DescribeJobError {
DescribeJobError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeJobError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeJobError {
fn description(&self) -> &str {
match *self {
DescribeJobError::InvalidResource(ref cause) => cause,
DescribeJobError::Validation(ref cause) => cause,
DescribeJobError::Credentials(ref err) => err.description(),
DescribeJobError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeJobError::ParseError(ref cause) => cause,
DescribeJobError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetJobManifestError {
InvalidJobState(String),
InvalidResource(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetJobManifestError {
pub fn from_response(res: BufferedHttpResponse) -> GetJobManifestError {
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 {
"InvalidJobStateException" => {
return GetJobManifestError::InvalidJobState(String::from(error_message));
}
"InvalidResourceException" => {
return GetJobManifestError::InvalidResource(String::from(error_message));
}
"ValidationException" => {
return GetJobManifestError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetJobManifestError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetJobManifestError {
fn from(err: serde_json::error::Error) -> GetJobManifestError {
GetJobManifestError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetJobManifestError {
fn from(err: CredentialsError) -> GetJobManifestError {
GetJobManifestError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetJobManifestError {
fn from(err: HttpDispatchError) -> GetJobManifestError {
GetJobManifestError::HttpDispatch(err)
}
}
impl From<io::Error> for GetJobManifestError {
fn from(err: io::Error) -> GetJobManifestError {
GetJobManifestError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetJobManifestError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetJobManifestError {
fn description(&self) -> &str {
match *self {
GetJobManifestError::InvalidJobState(ref cause) => cause,
GetJobManifestError::InvalidResource(ref cause) => cause,
GetJobManifestError::Validation(ref cause) => cause,
GetJobManifestError::Credentials(ref err) => err.description(),
GetJobManifestError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetJobManifestError::ParseError(ref cause) => cause,
GetJobManifestError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetJobUnlockCodeError {
InvalidJobState(String),
InvalidResource(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetJobUnlockCodeError {
pub fn from_response(res: BufferedHttpResponse) -> GetJobUnlockCodeError {
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 {
"InvalidJobStateException" => {
return GetJobUnlockCodeError::InvalidJobState(String::from(error_message));
}
"InvalidResourceException" => {
return GetJobUnlockCodeError::InvalidResource(String::from(error_message));
}
"ValidationException" => {
return GetJobUnlockCodeError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetJobUnlockCodeError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetJobUnlockCodeError {
fn from(err: serde_json::error::Error) -> GetJobUnlockCodeError {
GetJobUnlockCodeError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetJobUnlockCodeError {
fn from(err: CredentialsError) -> GetJobUnlockCodeError {
GetJobUnlockCodeError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetJobUnlockCodeError {
fn from(err: HttpDispatchError) -> GetJobUnlockCodeError {
GetJobUnlockCodeError::HttpDispatch(err)
}
}
impl From<io::Error> for GetJobUnlockCodeError {
fn from(err: io::Error) -> GetJobUnlockCodeError {
GetJobUnlockCodeError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetJobUnlockCodeError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetJobUnlockCodeError {
fn description(&self) -> &str {
match *self {
GetJobUnlockCodeError::InvalidJobState(ref cause) => cause,
GetJobUnlockCodeError::InvalidResource(ref cause) => cause,
GetJobUnlockCodeError::Validation(ref cause) => cause,
GetJobUnlockCodeError::Credentials(ref err) => err.description(),
GetJobUnlockCodeError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetJobUnlockCodeError::ParseError(ref cause) => cause,
GetJobUnlockCodeError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetSnowballUsageError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetSnowballUsageError {
pub fn from_response(res: BufferedHttpResponse) -> GetSnowballUsageError {
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 GetSnowballUsageError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetSnowballUsageError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetSnowballUsageError {
fn from(err: serde_json::error::Error) -> GetSnowballUsageError {
GetSnowballUsageError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetSnowballUsageError {
fn from(err: CredentialsError) -> GetSnowballUsageError {
GetSnowballUsageError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetSnowballUsageError {
fn from(err: HttpDispatchError) -> GetSnowballUsageError {
GetSnowballUsageError::HttpDispatch(err)
}
}
impl From<io::Error> for GetSnowballUsageError {
fn from(err: io::Error) -> GetSnowballUsageError {
GetSnowballUsageError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetSnowballUsageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetSnowballUsageError {
fn description(&self) -> &str {
match *self {
GetSnowballUsageError::Validation(ref cause) => cause,
GetSnowballUsageError::Credentials(ref err) => err.description(),
GetSnowballUsageError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetSnowballUsageError::ParseError(ref cause) => cause,
GetSnowballUsageError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListClusterJobsError {
InvalidNextToken(String),
InvalidResource(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListClusterJobsError {
pub fn from_response(res: BufferedHttpResponse) -> ListClusterJobsError {
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 {
"InvalidNextTokenException" => {
return ListClusterJobsError::InvalidNextToken(String::from(error_message));
}
"InvalidResourceException" => {
return ListClusterJobsError::InvalidResource(String::from(error_message));
}
"ValidationException" => {
return ListClusterJobsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListClusterJobsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListClusterJobsError {
fn from(err: serde_json::error::Error) -> ListClusterJobsError {
ListClusterJobsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListClusterJobsError {
fn from(err: CredentialsError) -> ListClusterJobsError {
ListClusterJobsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListClusterJobsError {
fn from(err: HttpDispatchError) -> ListClusterJobsError {
ListClusterJobsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListClusterJobsError {
fn from(err: io::Error) -> ListClusterJobsError {
ListClusterJobsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListClusterJobsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListClusterJobsError {
fn description(&self) -> &str {
match *self {
ListClusterJobsError::InvalidNextToken(ref cause) => cause,
ListClusterJobsError::InvalidResource(ref cause) => cause,
ListClusterJobsError::Validation(ref cause) => cause,
ListClusterJobsError::Credentials(ref err) => err.description(),
ListClusterJobsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListClusterJobsError::ParseError(ref cause) => cause,
ListClusterJobsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListClustersError {
InvalidNextToken(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListClustersError {
pub fn from_response(res: BufferedHttpResponse) -> ListClustersError {
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 {
"InvalidNextTokenException" => {
return ListClustersError::InvalidNextToken(String::from(error_message));
}
"ValidationException" => {
return ListClustersError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListClustersError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListClustersError {
fn from(err: serde_json::error::Error) -> ListClustersError {
ListClustersError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListClustersError {
fn from(err: CredentialsError) -> ListClustersError {
ListClustersError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListClustersError {
fn from(err: HttpDispatchError) -> ListClustersError {
ListClustersError::HttpDispatch(err)
}
}
impl From<io::Error> for ListClustersError {
fn from(err: io::Error) -> ListClustersError {
ListClustersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListClustersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListClustersError {
fn description(&self) -> &str {
match *self {
ListClustersError::InvalidNextToken(ref cause) => cause,
ListClustersError::Validation(ref cause) => cause,
ListClustersError::Credentials(ref err) => err.description(),
ListClustersError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListClustersError::ParseError(ref cause) => cause,
ListClustersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListCompatibleImagesError {
Ec2RequestFailed(String),
InvalidNextToken(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListCompatibleImagesError {
pub fn from_response(res: BufferedHttpResponse) -> ListCompatibleImagesError {
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 {
"Ec2RequestFailedException" => {
return ListCompatibleImagesError::Ec2RequestFailed(String::from(error_message));
}
"InvalidNextTokenException" => {
return ListCompatibleImagesError::InvalidNextToken(String::from(error_message));
}
"ValidationException" => {
return ListCompatibleImagesError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListCompatibleImagesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListCompatibleImagesError {
fn from(err: serde_json::error::Error) -> ListCompatibleImagesError {
ListCompatibleImagesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListCompatibleImagesError {
fn from(err: CredentialsError) -> ListCompatibleImagesError {
ListCompatibleImagesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListCompatibleImagesError {
fn from(err: HttpDispatchError) -> ListCompatibleImagesError {
ListCompatibleImagesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListCompatibleImagesError {
fn from(err: io::Error) -> ListCompatibleImagesError {
ListCompatibleImagesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListCompatibleImagesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListCompatibleImagesError {
fn description(&self) -> &str {
match *self {
ListCompatibleImagesError::Ec2RequestFailed(ref cause) => cause,
ListCompatibleImagesError::InvalidNextToken(ref cause) => cause,
ListCompatibleImagesError::Validation(ref cause) => cause,
ListCompatibleImagesError::Credentials(ref err) => err.description(),
ListCompatibleImagesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListCompatibleImagesError::ParseError(ref cause) => cause,
ListCompatibleImagesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListJobsError {
InvalidNextToken(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListJobsError {
pub fn from_response(res: BufferedHttpResponse) -> ListJobsError {
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 {
"InvalidNextTokenException" => {
return ListJobsError::InvalidNextToken(String::from(error_message));
}
"ValidationException" => {
return ListJobsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListJobsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListJobsError {
fn from(err: serde_json::error::Error) -> ListJobsError {
ListJobsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListJobsError {
fn from(err: CredentialsError) -> ListJobsError {
ListJobsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListJobsError {
fn from(err: HttpDispatchError) -> ListJobsError {
ListJobsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListJobsError {
fn from(err: io::Error) -> ListJobsError {
ListJobsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListJobsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListJobsError {
fn description(&self) -> &str {
match *self {
ListJobsError::InvalidNextToken(ref cause) => cause,
ListJobsError::Validation(ref cause) => cause,
ListJobsError::Credentials(ref err) => err.description(),
ListJobsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListJobsError::ParseError(ref cause) => cause,
ListJobsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateClusterError {
Ec2RequestFailed(String),
InvalidInputCombination(String),
InvalidJobState(String),
InvalidResource(String),
KMSRequestFailed(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateClusterError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateClusterError {
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 {
"Ec2RequestFailedException" => {
return UpdateClusterError::Ec2RequestFailed(String::from(error_message));
}
"InvalidInputCombinationException" => {
return UpdateClusterError::InvalidInputCombination(String::from(error_message));
}
"InvalidJobStateException" => {
return UpdateClusterError::InvalidJobState(String::from(error_message));
}
"InvalidResourceException" => {
return UpdateClusterError::InvalidResource(String::from(error_message));
}
"KMSRequestFailedException" => {
return UpdateClusterError::KMSRequestFailed(String::from(error_message));
}
"ValidationException" => {
return UpdateClusterError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateClusterError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateClusterError {
fn from(err: serde_json::error::Error) -> UpdateClusterError {
UpdateClusterError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateClusterError {
fn from(err: CredentialsError) -> UpdateClusterError {
UpdateClusterError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateClusterError {
fn from(err: HttpDispatchError) -> UpdateClusterError {
UpdateClusterError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateClusterError {
fn from(err: io::Error) -> UpdateClusterError {
UpdateClusterError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateClusterError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateClusterError {
fn description(&self) -> &str {
match *self {
UpdateClusterError::Ec2RequestFailed(ref cause) => cause,
UpdateClusterError::InvalidInputCombination(ref cause) => cause,
UpdateClusterError::InvalidJobState(ref cause) => cause,
UpdateClusterError::InvalidResource(ref cause) => cause,
UpdateClusterError::KMSRequestFailed(ref cause) => cause,
UpdateClusterError::Validation(ref cause) => cause,
UpdateClusterError::Credentials(ref err) => err.description(),
UpdateClusterError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateClusterError::ParseError(ref cause) => cause,
UpdateClusterError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateJobError {
ClusterLimitExceeded(String),
Ec2RequestFailed(String),
InvalidInputCombination(String),
InvalidJobState(String),
InvalidResource(String),
KMSRequestFailed(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateJobError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateJobError {
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 {
"ClusterLimitExceededException" => {
return UpdateJobError::ClusterLimitExceeded(String::from(error_message));
}
"Ec2RequestFailedException" => {
return UpdateJobError::Ec2RequestFailed(String::from(error_message));
}
"InvalidInputCombinationException" => {
return UpdateJobError::InvalidInputCombination(String::from(error_message));
}
"InvalidJobStateException" => {
return UpdateJobError::InvalidJobState(String::from(error_message));
}
"InvalidResourceException" => {
return UpdateJobError::InvalidResource(String::from(error_message));
}
"KMSRequestFailedException" => {
return UpdateJobError::KMSRequestFailed(String::from(error_message));
}
"ValidationException" => {
return UpdateJobError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateJobError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateJobError {
fn from(err: serde_json::error::Error) -> UpdateJobError {
UpdateJobError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateJobError {
fn from(err: CredentialsError) -> UpdateJobError {
UpdateJobError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateJobError {
fn from(err: HttpDispatchError) -> UpdateJobError {
UpdateJobError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateJobError {
fn from(err: io::Error) -> UpdateJobError {
UpdateJobError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateJobError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateJobError {
fn description(&self) -> &str {
match *self {
UpdateJobError::ClusterLimitExceeded(ref cause) => cause,
UpdateJobError::Ec2RequestFailed(ref cause) => cause,
UpdateJobError::InvalidInputCombination(ref cause) => cause,
UpdateJobError::InvalidJobState(ref cause) => cause,
UpdateJobError::InvalidResource(ref cause) => cause,
UpdateJobError::KMSRequestFailed(ref cause) => cause,
UpdateJobError::Validation(ref cause) => cause,
UpdateJobError::Credentials(ref err) => err.description(),
UpdateJobError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateJobError::ParseError(ref cause) => cause,
UpdateJobError::Unknown(_) => "unknown error",
}
}
}
pub trait Snowball {
fn cancel_cluster(
&self,
input: CancelClusterRequest,
) -> RusotoFuture<CancelClusterResult, CancelClusterError>;
fn cancel_job(&self, input: CancelJobRequest) -> RusotoFuture<CancelJobResult, CancelJobError>;
fn create_address(
&self,
input: CreateAddressRequest,
) -> RusotoFuture<CreateAddressResult, CreateAddressError>;
fn create_cluster(
&self,
input: CreateClusterRequest,
) -> RusotoFuture<CreateClusterResult, CreateClusterError>;
fn create_job(&self, input: CreateJobRequest) -> RusotoFuture<CreateJobResult, CreateJobError>;
fn describe_address(
&self,
input: DescribeAddressRequest,
) -> RusotoFuture<DescribeAddressResult, DescribeAddressError>;
fn describe_addresses(
&self,
input: DescribeAddressesRequest,
) -> RusotoFuture<DescribeAddressesResult, DescribeAddressesError>;
fn describe_cluster(
&self,
input: DescribeClusterRequest,
) -> RusotoFuture<DescribeClusterResult, DescribeClusterError>;
fn describe_job(
&self,
input: DescribeJobRequest,
) -> RusotoFuture<DescribeJobResult, DescribeJobError>;
fn get_job_manifest(
&self,
input: GetJobManifestRequest,
) -> RusotoFuture<GetJobManifestResult, GetJobManifestError>;
fn get_job_unlock_code(
&self,
input: GetJobUnlockCodeRequest,
) -> RusotoFuture<GetJobUnlockCodeResult, GetJobUnlockCodeError>;
fn get_snowball_usage(&self) -> RusotoFuture<GetSnowballUsageResult, GetSnowballUsageError>;
fn list_cluster_jobs(
&self,
input: ListClusterJobsRequest,
) -> RusotoFuture<ListClusterJobsResult, ListClusterJobsError>;
fn list_clusters(
&self,
input: ListClustersRequest,
) -> RusotoFuture<ListClustersResult, ListClustersError>;
fn list_compatible_images(
&self,
input: ListCompatibleImagesRequest,
) -> RusotoFuture<ListCompatibleImagesResult, ListCompatibleImagesError>;
fn list_jobs(&self, input: ListJobsRequest) -> RusotoFuture<ListJobsResult, ListJobsError>;
fn update_cluster(
&self,
input: UpdateClusterRequest,
) -> RusotoFuture<UpdateClusterResult, UpdateClusterError>;
fn update_job(&self, input: UpdateJobRequest) -> RusotoFuture<UpdateJobResult, UpdateJobError>;
}
#[derive(Clone)]
pub struct SnowballClient {
client: Client,
region: region::Region,
}
impl SnowballClient {
pub fn new(region: region::Region) -> SnowballClient {
SnowballClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> SnowballClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
SnowballClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl Snowball for SnowballClient {
fn cancel_cluster(
&self,
input: CancelClusterRequest,
) -> RusotoFuture<CancelClusterResult, CancelClusterError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.CancelCluster",
);
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::<CancelClusterResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CancelClusterError::from_response(response))),
)
}
})
}
fn cancel_job(&self, input: CancelJobRequest) -> RusotoFuture<CancelJobResult, CancelJobError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.CancelJob",
);
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::<CancelJobResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CancelJobError::from_response(response))),
)
}
})
}
fn create_address(
&self,
input: CreateAddressRequest,
) -> RusotoFuture<CreateAddressResult, CreateAddressError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.CreateAddress",
);
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::<CreateAddressResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateAddressError::from_response(response))),
)
}
})
}
fn create_cluster(
&self,
input: CreateClusterRequest,
) -> RusotoFuture<CreateClusterResult, CreateClusterError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.CreateCluster",
);
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::<CreateClusterResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateClusterError::from_response(response))),
)
}
})
}
fn create_job(&self, input: CreateJobRequest) -> RusotoFuture<CreateJobResult, CreateJobError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.CreateJob",
);
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::<CreateJobResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateJobError::from_response(response))),
)
}
})
}
fn describe_address(
&self,
input: DescribeAddressRequest,
) -> RusotoFuture<DescribeAddressResult, DescribeAddressError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.DescribeAddress",
);
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::<DescribeAddressResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeAddressError::from_response(response))),
)
}
})
}
fn describe_addresses(
&self,
input: DescribeAddressesRequest,
) -> RusotoFuture<DescribeAddressesResult, DescribeAddressesError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.DescribeAddresses",
);
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::<DescribeAddressesResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeAddressesError::from_response(response))),
)
}
})
}
fn describe_cluster(
&self,
input: DescribeClusterRequest,
) -> RusotoFuture<DescribeClusterResult, DescribeClusterError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.DescribeCluster",
);
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::<DescribeClusterResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeClusterError::from_response(response))),
)
}
})
}
fn describe_job(
&self,
input: DescribeJobRequest,
) -> RusotoFuture<DescribeJobResult, DescribeJobError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.DescribeJob",
);
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::<DescribeJobResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeJobError::from_response(response))),
)
}
})
}
fn get_job_manifest(
&self,
input: GetJobManifestRequest,
) -> RusotoFuture<GetJobManifestResult, GetJobManifestError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.GetJobManifest",
);
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::<GetJobManifestResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetJobManifestError::from_response(response))),
)
}
})
}
fn get_job_unlock_code(
&self,
input: GetJobUnlockCodeRequest,
) -> RusotoFuture<GetJobUnlockCodeResult, GetJobUnlockCodeError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.GetJobUnlockCode",
);
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::<GetJobUnlockCodeResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetJobUnlockCodeError::from_response(response))),
)
}
})
}
fn get_snowball_usage(&self) -> RusotoFuture<GetSnowballUsageResult, GetSnowballUsageError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.GetSnowballUsage",
);
request.set_payload(Some(b"{}".to_vec()));
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::<GetSnowballUsageResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetSnowballUsageError::from_response(response))),
)
}
})
}
fn list_cluster_jobs(
&self,
input: ListClusterJobsRequest,
) -> RusotoFuture<ListClusterJobsResult, ListClusterJobsError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.ListClusterJobs",
);
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::<ListClusterJobsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListClusterJobsError::from_response(response))),
)
}
})
}
fn list_clusters(
&self,
input: ListClustersRequest,
) -> RusotoFuture<ListClustersResult, ListClustersError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.ListClusters",
);
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::<ListClustersResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListClustersError::from_response(response))),
)
}
})
}
fn list_compatible_images(
&self,
input: ListCompatibleImagesRequest,
) -> RusotoFuture<ListCompatibleImagesResult, ListCompatibleImagesError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.ListCompatibleImages",
);
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::<ListCompatibleImagesResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListCompatibleImagesError::from_response(response))
}),
)
}
})
}
fn list_jobs(&self, input: ListJobsRequest) -> RusotoFuture<ListJobsResult, ListJobsError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSIESnowballJobManagementService.ListJobs");
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::<ListJobsResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListJobsError::from_response(response))),
)
}
})
}
fn update_cluster(
&self,
input: UpdateClusterRequest,
) -> RusotoFuture<UpdateClusterResult, UpdateClusterError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.UpdateCluster",
);
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::<UpdateClusterResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateClusterError::from_response(response))),
)
}
})
}
fn update_job(&self, input: UpdateJobRequest) -> RusotoFuture<UpdateJobResult, UpdateJobError> {
let mut request = SignedRequest::new("POST", "snowball", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AWSIESnowballJobManagementService.UpdateJob",
);
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::<UpdateJobResult>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateJobError::from_response(response))),
)
}
})
}
}
#[cfg(test)]
mod protocol_tests {}