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 AuthorizationData {
#[serde(rename = "authorizationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_token: Option<String>,
#[serde(rename = "expiresAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expires_at: Option<f64>,
#[serde(rename = "proxyEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proxy_endpoint: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct BatchCheckLayerAvailabilityRequest {
#[serde(rename = "layerDigests")]
pub layer_digests: Vec<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BatchCheckLayerAvailabilityResponse {
#[serde(rename = "failures")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failures: Option<Vec<LayerFailure>>,
#[serde(rename = "layers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layers: Option<Vec<Layer>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct BatchDeleteImageRequest {
#[serde(rename = "imageIds")]
pub image_ids: Vec<ImageIdentifier>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BatchDeleteImageResponse {
#[serde(rename = "failures")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failures: Option<Vec<ImageFailure>>,
#[serde(rename = "imageIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_ids: Option<Vec<ImageIdentifier>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct BatchGetImageRequest {
#[serde(rename = "acceptedMediaTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accepted_media_types: Option<Vec<String>>,
#[serde(rename = "imageIds")]
pub image_ids: Vec<ImageIdentifier>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BatchGetImageResponse {
#[serde(rename = "failures")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failures: Option<Vec<ImageFailure>>,
#[serde(rename = "images")]
#[serde(skip_serializing_if = "Option::is_none")]
pub images: Option<Vec<Image>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CompleteLayerUploadRequest {
#[serde(rename = "layerDigests")]
pub layer_digests: Vec<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "uploadId")]
pub upload_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CompleteLayerUploadResponse {
#[serde(rename = "layerDigest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_digest: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
#[serde(rename = "uploadId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upload_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateRepositoryRequest {
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateRepositoryResponse {
#[serde(rename = "repository")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository: Option<Repository>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteLifecyclePolicyRequest {
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteLifecyclePolicyResponse {
#[serde(rename = "lastEvaluatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_evaluated_at: Option<f64>,
#[serde(rename = "lifecyclePolicyText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_policy_text: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteRepositoryPolicyRequest {
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteRepositoryPolicyResponse {
#[serde(rename = "policyText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy_text: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteRepositoryRequest {
#[serde(rename = "force")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force: Option<bool>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteRepositoryResponse {
#[serde(rename = "repository")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository: Option<Repository>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeImagesFilter {
#[serde(rename = "tagStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeImagesRequest {
#[serde(rename = "filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<DescribeImagesFilter>,
#[serde(rename = "imageIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_ids: Option<Vec<ImageIdentifier>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeImagesResponse {
#[serde(rename = "imageDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_details: Option<Vec<ImageDetail>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeRepositoriesRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_names: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeRepositoriesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "repositories")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repositories: Option<Vec<Repository>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetAuthorizationTokenRequest {
#[serde(rename = "registryIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_ids: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetAuthorizationTokenResponse {
#[serde(rename = "authorizationData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_data: Option<Vec<AuthorizationData>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetDownloadUrlForLayerRequest {
#[serde(rename = "layerDigest")]
pub layer_digest: String,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetDownloadUrlForLayerResponse {
#[serde(rename = "downloadUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub download_url: Option<String>,
#[serde(rename = "layerDigest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_digest: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetLifecyclePolicyPreviewRequest {
#[serde(rename = "filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<LifecyclePolicyPreviewFilter>,
#[serde(rename = "imageIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_ids: Option<Vec<ImageIdentifier>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetLifecyclePolicyPreviewResponse {
#[serde(rename = "lifecyclePolicyText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_policy_text: Option<String>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "previewResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preview_results: Option<Vec<LifecyclePolicyPreviewResult>>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "summary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summary: Option<LifecyclePolicyPreviewSummary>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetLifecyclePolicyRequest {
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetLifecyclePolicyResponse {
#[serde(rename = "lastEvaluatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_evaluated_at: Option<f64>,
#[serde(rename = "lifecyclePolicyText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_policy_text: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetRepositoryPolicyRequest {
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetRepositoryPolicyResponse {
#[serde(rename = "policyText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy_text: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Image {
#[serde(rename = "imageId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_id: Option<ImageIdentifier>,
#[serde(rename = "imageManifest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_manifest: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ImageDetail {
#[serde(rename = "imageDigest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_digest: Option<String>,
#[serde(rename = "imagePushedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_pushed_at: Option<f64>,
#[serde(rename = "imageSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_size_in_bytes: Option<i64>,
#[serde(rename = "imageTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_tags: Option<Vec<String>>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ImageFailure {
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "imageId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_id: Option<ImageIdentifier>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ImageIdentifier {
#[serde(rename = "imageDigest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_digest: Option<String>,
#[serde(rename = "imageTag")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_tag: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct InitiateLayerUploadRequest {
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct InitiateLayerUploadResponse {
#[serde(rename = "partSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub part_size: Option<i64>,
#[serde(rename = "uploadId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upload_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Layer {
#[serde(rename = "layerAvailability")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_availability: Option<String>,
#[serde(rename = "layerDigest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_digest: Option<String>,
#[serde(rename = "layerSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_size: Option<i64>,
#[serde(rename = "mediaType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct LayerFailure {
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "layerDigest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_digest: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct LifecyclePolicyPreviewFilter {
#[serde(rename = "tagStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct LifecyclePolicyPreviewResult {
#[serde(rename = "action")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action: Option<LifecyclePolicyRuleAction>,
#[serde(rename = "appliedRulePriority")]
#[serde(skip_serializing_if = "Option::is_none")]
pub applied_rule_priority: Option<i64>,
#[serde(rename = "imageDigest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_digest: Option<String>,
#[serde(rename = "imagePushedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_pushed_at: Option<f64>,
#[serde(rename = "imageTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_tags: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct LifecyclePolicyPreviewSummary {
#[serde(rename = "expiringImageTotalCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiring_image_total_count: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct LifecyclePolicyRuleAction {
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListImagesFilter {
#[serde(rename = "tagStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListImagesRequest {
#[serde(rename = "filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<ListImagesFilter>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListImagesResponse {
#[serde(rename = "imageIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_ids: Option<Vec<ImageIdentifier>>,
#[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<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct PutImageRequest {
#[serde(rename = "imageManifest")]
pub image_manifest: String,
#[serde(rename = "imageTag")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_tag: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct PutImageResponse {
#[serde(rename = "image")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image: Option<Image>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct PutLifecyclePolicyRequest {
#[serde(rename = "lifecyclePolicyText")]
pub lifecycle_policy_text: String,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct PutLifecyclePolicyResponse {
#[serde(rename = "lifecyclePolicyText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_policy_text: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Repository {
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_arn: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
#[serde(rename = "repositoryUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_uri: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct SetRepositoryPolicyRequest {
#[serde(rename = "force")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force: Option<bool>,
#[serde(rename = "policyText")]
pub policy_text: String,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct SetRepositoryPolicyResponse {
#[serde(rename = "policyText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy_text: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartLifecyclePolicyPreviewRequest {
#[serde(rename = "lifecyclePolicyText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_policy_text: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StartLifecyclePolicyPreviewResponse {
#[serde(rename = "lifecyclePolicyText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle_policy_text: Option<String>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Tag {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct TagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tags")]
pub tags: Vec<Tag>,
}
#[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 UploadLayerPartRequest {
#[serde(rename = "layerPartBlob")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
pub layer_part_blob: Vec<u8>,
#[serde(rename = "partFirstByte")]
pub part_first_byte: i64,
#[serde(rename = "partLastByte")]
pub part_last_byte: i64,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "uploadId")]
pub upload_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UploadLayerPartResponse {
#[serde(rename = "lastByteReceived")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_byte_received: Option<i64>,
#[serde(rename = "registryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registry_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
#[serde(rename = "uploadId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upload_id: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum BatchCheckLayerAvailabilityError {
InvalidParameter(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl BatchCheckLayerAvailabilityError {
pub fn from_response(res: BufferedHttpResponse) -> BatchCheckLayerAvailabilityError {
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 {
"InvalidParameterException" => {
return BatchCheckLayerAvailabilityError::InvalidParameter(String::from(
error_message,
));
}
"RepositoryNotFoundException" => {
return BatchCheckLayerAvailabilityError::RepositoryNotFound(String::from(
error_message,
));
}
"ServerException" => {
return BatchCheckLayerAvailabilityError::Server(String::from(error_message));
}
"ValidationException" => {
return BatchCheckLayerAvailabilityError::Validation(error_message.to_string());
}
_ => {}
}
}
return BatchCheckLayerAvailabilityError::Unknown(res);
}
}
impl From<serde_json::error::Error> for BatchCheckLayerAvailabilityError {
fn from(err: serde_json::error::Error) -> BatchCheckLayerAvailabilityError {
BatchCheckLayerAvailabilityError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for BatchCheckLayerAvailabilityError {
fn from(err: CredentialsError) -> BatchCheckLayerAvailabilityError {
BatchCheckLayerAvailabilityError::Credentials(err)
}
}
impl From<HttpDispatchError> for BatchCheckLayerAvailabilityError {
fn from(err: HttpDispatchError) -> BatchCheckLayerAvailabilityError {
BatchCheckLayerAvailabilityError::HttpDispatch(err)
}
}
impl From<io::Error> for BatchCheckLayerAvailabilityError {
fn from(err: io::Error) -> BatchCheckLayerAvailabilityError {
BatchCheckLayerAvailabilityError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for BatchCheckLayerAvailabilityError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for BatchCheckLayerAvailabilityError {
fn description(&self) -> &str {
match *self {
BatchCheckLayerAvailabilityError::InvalidParameter(ref cause) => cause,
BatchCheckLayerAvailabilityError::RepositoryNotFound(ref cause) => cause,
BatchCheckLayerAvailabilityError::Server(ref cause) => cause,
BatchCheckLayerAvailabilityError::Validation(ref cause) => cause,
BatchCheckLayerAvailabilityError::Credentials(ref err) => err.description(),
BatchCheckLayerAvailabilityError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
BatchCheckLayerAvailabilityError::ParseError(ref cause) => cause,
BatchCheckLayerAvailabilityError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum BatchDeleteImageError {
InvalidParameter(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl BatchDeleteImageError {
pub fn from_response(res: BufferedHttpResponse) -> BatchDeleteImageError {
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 {
"InvalidParameterException" => {
return BatchDeleteImageError::InvalidParameter(String::from(error_message));
}
"RepositoryNotFoundException" => {
return BatchDeleteImageError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => {
return BatchDeleteImageError::Server(String::from(error_message));
}
"ValidationException" => {
return BatchDeleteImageError::Validation(error_message.to_string());
}
_ => {}
}
}
return BatchDeleteImageError::Unknown(res);
}
}
impl From<serde_json::error::Error> for BatchDeleteImageError {
fn from(err: serde_json::error::Error) -> BatchDeleteImageError {
BatchDeleteImageError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for BatchDeleteImageError {
fn from(err: CredentialsError) -> BatchDeleteImageError {
BatchDeleteImageError::Credentials(err)
}
}
impl From<HttpDispatchError> for BatchDeleteImageError {
fn from(err: HttpDispatchError) -> BatchDeleteImageError {
BatchDeleteImageError::HttpDispatch(err)
}
}
impl From<io::Error> for BatchDeleteImageError {
fn from(err: io::Error) -> BatchDeleteImageError {
BatchDeleteImageError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for BatchDeleteImageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for BatchDeleteImageError {
fn description(&self) -> &str {
match *self {
BatchDeleteImageError::InvalidParameter(ref cause) => cause,
BatchDeleteImageError::RepositoryNotFound(ref cause) => cause,
BatchDeleteImageError::Server(ref cause) => cause,
BatchDeleteImageError::Validation(ref cause) => cause,
BatchDeleteImageError::Credentials(ref err) => err.description(),
BatchDeleteImageError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
BatchDeleteImageError::ParseError(ref cause) => cause,
BatchDeleteImageError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum BatchGetImageError {
InvalidParameter(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl BatchGetImageError {
pub fn from_response(res: BufferedHttpResponse) -> BatchGetImageError {
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 {
"InvalidParameterException" => {
return BatchGetImageError::InvalidParameter(String::from(error_message));
}
"RepositoryNotFoundException" => {
return BatchGetImageError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => return BatchGetImageError::Server(String::from(error_message)),
"ValidationException" => {
return BatchGetImageError::Validation(error_message.to_string());
}
_ => {}
}
}
return BatchGetImageError::Unknown(res);
}
}
impl From<serde_json::error::Error> for BatchGetImageError {
fn from(err: serde_json::error::Error) -> BatchGetImageError {
BatchGetImageError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for BatchGetImageError {
fn from(err: CredentialsError) -> BatchGetImageError {
BatchGetImageError::Credentials(err)
}
}
impl From<HttpDispatchError> for BatchGetImageError {
fn from(err: HttpDispatchError) -> BatchGetImageError {
BatchGetImageError::HttpDispatch(err)
}
}
impl From<io::Error> for BatchGetImageError {
fn from(err: io::Error) -> BatchGetImageError {
BatchGetImageError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for BatchGetImageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for BatchGetImageError {
fn description(&self) -> &str {
match *self {
BatchGetImageError::InvalidParameter(ref cause) => cause,
BatchGetImageError::RepositoryNotFound(ref cause) => cause,
BatchGetImageError::Server(ref cause) => cause,
BatchGetImageError::Validation(ref cause) => cause,
BatchGetImageError::Credentials(ref err) => err.description(),
BatchGetImageError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
BatchGetImageError::ParseError(ref cause) => cause,
BatchGetImageError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CompleteLayerUploadError {
EmptyUpload(String),
InvalidLayer(String),
InvalidParameter(String),
LayerAlreadyExists(String),
LayerPartTooSmall(String),
RepositoryNotFound(String),
Server(String),
UploadNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CompleteLayerUploadError {
pub fn from_response(res: BufferedHttpResponse) -> CompleteLayerUploadError {
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 {
"EmptyUploadException" => {
return CompleteLayerUploadError::EmptyUpload(String::from(error_message));
}
"InvalidLayerException" => {
return CompleteLayerUploadError::InvalidLayer(String::from(error_message));
}
"InvalidParameterException" => {
return CompleteLayerUploadError::InvalidParameter(String::from(error_message));
}
"LayerAlreadyExistsException" => {
return CompleteLayerUploadError::LayerAlreadyExists(String::from(error_message));
}
"LayerPartTooSmallException" => {
return CompleteLayerUploadError::LayerPartTooSmall(String::from(error_message));
}
"RepositoryNotFoundException" => {
return CompleteLayerUploadError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => {
return CompleteLayerUploadError::Server(String::from(error_message));
}
"UploadNotFoundException" => {
return CompleteLayerUploadError::UploadNotFound(String::from(error_message));
}
"ValidationException" => {
return CompleteLayerUploadError::Validation(error_message.to_string());
}
_ => {}
}
}
return CompleteLayerUploadError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CompleteLayerUploadError {
fn from(err: serde_json::error::Error) -> CompleteLayerUploadError {
CompleteLayerUploadError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CompleteLayerUploadError {
fn from(err: CredentialsError) -> CompleteLayerUploadError {
CompleteLayerUploadError::Credentials(err)
}
}
impl From<HttpDispatchError> for CompleteLayerUploadError {
fn from(err: HttpDispatchError) -> CompleteLayerUploadError {
CompleteLayerUploadError::HttpDispatch(err)
}
}
impl From<io::Error> for CompleteLayerUploadError {
fn from(err: io::Error) -> CompleteLayerUploadError {
CompleteLayerUploadError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CompleteLayerUploadError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CompleteLayerUploadError {
fn description(&self) -> &str {
match *self {
CompleteLayerUploadError::EmptyUpload(ref cause) => cause,
CompleteLayerUploadError::InvalidLayer(ref cause) => cause,
CompleteLayerUploadError::InvalidParameter(ref cause) => cause,
CompleteLayerUploadError::LayerAlreadyExists(ref cause) => cause,
CompleteLayerUploadError::LayerPartTooSmall(ref cause) => cause,
CompleteLayerUploadError::RepositoryNotFound(ref cause) => cause,
CompleteLayerUploadError::Server(ref cause) => cause,
CompleteLayerUploadError::UploadNotFound(ref cause) => cause,
CompleteLayerUploadError::Validation(ref cause) => cause,
CompleteLayerUploadError::Credentials(ref err) => err.description(),
CompleteLayerUploadError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CompleteLayerUploadError::ParseError(ref cause) => cause,
CompleteLayerUploadError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateRepositoryError {
InvalidParameter(String),
InvalidTagParameter(String),
LimitExceeded(String),
RepositoryAlreadyExists(String),
Server(String),
TooManyTags(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateRepositoryError {
pub fn from_response(res: BufferedHttpResponse) -> CreateRepositoryError {
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 {
"InvalidParameterException" => {
return CreateRepositoryError::InvalidParameter(String::from(error_message));
}
"InvalidTagParameterException" => {
return CreateRepositoryError::InvalidTagParameter(String::from(error_message));
}
"LimitExceededException" => {
return CreateRepositoryError::LimitExceeded(String::from(error_message));
}
"RepositoryAlreadyExistsException" => {
return CreateRepositoryError::RepositoryAlreadyExists(String::from(
error_message,
));
}
"ServerException" => {
return CreateRepositoryError::Server(String::from(error_message));
}
"TooManyTagsException" => {
return CreateRepositoryError::TooManyTags(String::from(error_message));
}
"ValidationException" => {
return CreateRepositoryError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateRepositoryError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateRepositoryError {
fn from(err: serde_json::error::Error) -> CreateRepositoryError {
CreateRepositoryError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateRepositoryError {
fn from(err: CredentialsError) -> CreateRepositoryError {
CreateRepositoryError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateRepositoryError {
fn from(err: HttpDispatchError) -> CreateRepositoryError {
CreateRepositoryError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateRepositoryError {
fn from(err: io::Error) -> CreateRepositoryError {
CreateRepositoryError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateRepositoryError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateRepositoryError {
fn description(&self) -> &str {
match *self {
CreateRepositoryError::InvalidParameter(ref cause) => cause,
CreateRepositoryError::InvalidTagParameter(ref cause) => cause,
CreateRepositoryError::LimitExceeded(ref cause) => cause,
CreateRepositoryError::RepositoryAlreadyExists(ref cause) => cause,
CreateRepositoryError::Server(ref cause) => cause,
CreateRepositoryError::TooManyTags(ref cause) => cause,
CreateRepositoryError::Validation(ref cause) => cause,
CreateRepositoryError::Credentials(ref err) => err.description(),
CreateRepositoryError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateRepositoryError::ParseError(ref cause) => cause,
CreateRepositoryError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteLifecyclePolicyError {
InvalidParameter(String),
LifecyclePolicyNotFound(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteLifecyclePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteLifecyclePolicyError {
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 {
"InvalidParameterException" => {
return DeleteLifecyclePolicyError::InvalidParameter(String::from(error_message));
}
"LifecyclePolicyNotFoundException" => {
return DeleteLifecyclePolicyError::LifecyclePolicyNotFound(String::from(
error_message,
));
}
"RepositoryNotFoundException" => {
return DeleteLifecyclePolicyError::RepositoryNotFound(String::from(
error_message,
));
}
"ServerException" => {
return DeleteLifecyclePolicyError::Server(String::from(error_message));
}
"ValidationException" => {
return DeleteLifecyclePolicyError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteLifecyclePolicyError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteLifecyclePolicyError {
fn from(err: serde_json::error::Error) -> DeleteLifecyclePolicyError {
DeleteLifecyclePolicyError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteLifecyclePolicyError {
fn from(err: CredentialsError) -> DeleteLifecyclePolicyError {
DeleteLifecyclePolicyError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteLifecyclePolicyError {
fn from(err: HttpDispatchError) -> DeleteLifecyclePolicyError {
DeleteLifecyclePolicyError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteLifecyclePolicyError {
fn from(err: io::Error) -> DeleteLifecyclePolicyError {
DeleteLifecyclePolicyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteLifecyclePolicyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteLifecyclePolicyError {
fn description(&self) -> &str {
match *self {
DeleteLifecyclePolicyError::InvalidParameter(ref cause) => cause,
DeleteLifecyclePolicyError::LifecyclePolicyNotFound(ref cause) => cause,
DeleteLifecyclePolicyError::RepositoryNotFound(ref cause) => cause,
DeleteLifecyclePolicyError::Server(ref cause) => cause,
DeleteLifecyclePolicyError::Validation(ref cause) => cause,
DeleteLifecyclePolicyError::Credentials(ref err) => err.description(),
DeleteLifecyclePolicyError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteLifecyclePolicyError::ParseError(ref cause) => cause,
DeleteLifecyclePolicyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteRepositoryError {
InvalidParameter(String),
RepositoryNotEmpty(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteRepositoryError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteRepositoryError {
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 {
"InvalidParameterException" => {
return DeleteRepositoryError::InvalidParameter(String::from(error_message));
}
"RepositoryNotEmptyException" => {
return DeleteRepositoryError::RepositoryNotEmpty(String::from(error_message));
}
"RepositoryNotFoundException" => {
return DeleteRepositoryError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => {
return DeleteRepositoryError::Server(String::from(error_message));
}
"ValidationException" => {
return DeleteRepositoryError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteRepositoryError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteRepositoryError {
fn from(err: serde_json::error::Error) -> DeleteRepositoryError {
DeleteRepositoryError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteRepositoryError {
fn from(err: CredentialsError) -> DeleteRepositoryError {
DeleteRepositoryError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteRepositoryError {
fn from(err: HttpDispatchError) -> DeleteRepositoryError {
DeleteRepositoryError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteRepositoryError {
fn from(err: io::Error) -> DeleteRepositoryError {
DeleteRepositoryError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteRepositoryError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteRepositoryError {
fn description(&self) -> &str {
match *self {
DeleteRepositoryError::InvalidParameter(ref cause) => cause,
DeleteRepositoryError::RepositoryNotEmpty(ref cause) => cause,
DeleteRepositoryError::RepositoryNotFound(ref cause) => cause,
DeleteRepositoryError::Server(ref cause) => cause,
DeleteRepositoryError::Validation(ref cause) => cause,
DeleteRepositoryError::Credentials(ref err) => err.description(),
DeleteRepositoryError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteRepositoryError::ParseError(ref cause) => cause,
DeleteRepositoryError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteRepositoryPolicyError {
InvalidParameter(String),
RepositoryNotFound(String),
RepositoryPolicyNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteRepositoryPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteRepositoryPolicyError {
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 {
"InvalidParameterException" => {
return DeleteRepositoryPolicyError::InvalidParameter(String::from(
error_message,
));
}
"RepositoryNotFoundException" => {
return DeleteRepositoryPolicyError::RepositoryNotFound(String::from(
error_message,
));
}
"RepositoryPolicyNotFoundException" => {
return DeleteRepositoryPolicyError::RepositoryPolicyNotFound(String::from(
error_message,
));
}
"ServerException" => {
return DeleteRepositoryPolicyError::Server(String::from(error_message));
}
"ValidationException" => {
return DeleteRepositoryPolicyError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteRepositoryPolicyError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteRepositoryPolicyError {
fn from(err: serde_json::error::Error) -> DeleteRepositoryPolicyError {
DeleteRepositoryPolicyError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteRepositoryPolicyError {
fn from(err: CredentialsError) -> DeleteRepositoryPolicyError {
DeleteRepositoryPolicyError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteRepositoryPolicyError {
fn from(err: HttpDispatchError) -> DeleteRepositoryPolicyError {
DeleteRepositoryPolicyError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteRepositoryPolicyError {
fn from(err: io::Error) -> DeleteRepositoryPolicyError {
DeleteRepositoryPolicyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteRepositoryPolicyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteRepositoryPolicyError {
fn description(&self) -> &str {
match *self {
DeleteRepositoryPolicyError::InvalidParameter(ref cause) => cause,
DeleteRepositoryPolicyError::RepositoryNotFound(ref cause) => cause,
DeleteRepositoryPolicyError::RepositoryPolicyNotFound(ref cause) => cause,
DeleteRepositoryPolicyError::Server(ref cause) => cause,
DeleteRepositoryPolicyError::Validation(ref cause) => cause,
DeleteRepositoryPolicyError::Credentials(ref err) => err.description(),
DeleteRepositoryPolicyError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteRepositoryPolicyError::ParseError(ref cause) => cause,
DeleteRepositoryPolicyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeImagesError {
ImageNotFound(String),
InvalidParameter(String),
RepositoryNotFound(String),
Server(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 {
"ImageNotFoundException" => {
return DescribeImagesError::ImageNotFound(String::from(error_message));
}
"InvalidParameterException" => {
return DescribeImagesError::InvalidParameter(String::from(error_message));
}
"RepositoryNotFoundException" => {
return DescribeImagesError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => {
return DescribeImagesError::Server(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::ImageNotFound(ref cause) => cause,
DescribeImagesError::InvalidParameter(ref cause) => cause,
DescribeImagesError::RepositoryNotFound(ref cause) => cause,
DescribeImagesError::Server(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 DescribeRepositoriesError {
InvalidParameter(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeRepositoriesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeRepositoriesError {
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 {
"InvalidParameterException" => {
return DescribeRepositoriesError::InvalidParameter(String::from(error_message));
}
"RepositoryNotFoundException" => {
return DescribeRepositoriesError::RepositoryNotFound(String::from(
error_message,
));
}
"ServerException" => {
return DescribeRepositoriesError::Server(String::from(error_message));
}
"ValidationException" => {
return DescribeRepositoriesError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeRepositoriesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeRepositoriesError {
fn from(err: serde_json::error::Error) -> DescribeRepositoriesError {
DescribeRepositoriesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeRepositoriesError {
fn from(err: CredentialsError) -> DescribeRepositoriesError {
DescribeRepositoriesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeRepositoriesError {
fn from(err: HttpDispatchError) -> DescribeRepositoriesError {
DescribeRepositoriesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeRepositoriesError {
fn from(err: io::Error) -> DescribeRepositoriesError {
DescribeRepositoriesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeRepositoriesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeRepositoriesError {
fn description(&self) -> &str {
match *self {
DescribeRepositoriesError::InvalidParameter(ref cause) => cause,
DescribeRepositoriesError::RepositoryNotFound(ref cause) => cause,
DescribeRepositoriesError::Server(ref cause) => cause,
DescribeRepositoriesError::Validation(ref cause) => cause,
DescribeRepositoriesError::Credentials(ref err) => err.description(),
DescribeRepositoriesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeRepositoriesError::ParseError(ref cause) => cause,
DescribeRepositoriesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetAuthorizationTokenError {
InvalidParameter(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetAuthorizationTokenError {
pub fn from_response(res: BufferedHttpResponse) -> GetAuthorizationTokenError {
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 {
"InvalidParameterException" => {
return GetAuthorizationTokenError::InvalidParameter(String::from(error_message));
}
"ServerException" => {
return GetAuthorizationTokenError::Server(String::from(error_message));
}
"ValidationException" => {
return GetAuthorizationTokenError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetAuthorizationTokenError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetAuthorizationTokenError {
fn from(err: serde_json::error::Error) -> GetAuthorizationTokenError {
GetAuthorizationTokenError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetAuthorizationTokenError {
fn from(err: CredentialsError) -> GetAuthorizationTokenError {
GetAuthorizationTokenError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetAuthorizationTokenError {
fn from(err: HttpDispatchError) -> GetAuthorizationTokenError {
GetAuthorizationTokenError::HttpDispatch(err)
}
}
impl From<io::Error> for GetAuthorizationTokenError {
fn from(err: io::Error) -> GetAuthorizationTokenError {
GetAuthorizationTokenError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetAuthorizationTokenError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetAuthorizationTokenError {
fn description(&self) -> &str {
match *self {
GetAuthorizationTokenError::InvalidParameter(ref cause) => cause,
GetAuthorizationTokenError::Server(ref cause) => cause,
GetAuthorizationTokenError::Validation(ref cause) => cause,
GetAuthorizationTokenError::Credentials(ref err) => err.description(),
GetAuthorizationTokenError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetAuthorizationTokenError::ParseError(ref cause) => cause,
GetAuthorizationTokenError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetDownloadUrlForLayerError {
InvalidParameter(String),
LayerInaccessible(String),
LayersNotFound(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetDownloadUrlForLayerError {
pub fn from_response(res: BufferedHttpResponse) -> GetDownloadUrlForLayerError {
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 {
"InvalidParameterException" => {
return GetDownloadUrlForLayerError::InvalidParameter(String::from(
error_message,
));
}
"LayerInaccessibleException" => {
return GetDownloadUrlForLayerError::LayerInaccessible(String::from(
error_message,
));
}
"LayersNotFoundException" => {
return GetDownloadUrlForLayerError::LayersNotFound(String::from(error_message));
}
"RepositoryNotFoundException" => {
return GetDownloadUrlForLayerError::RepositoryNotFound(String::from(
error_message,
));
}
"ServerException" => {
return GetDownloadUrlForLayerError::Server(String::from(error_message));
}
"ValidationException" => {
return GetDownloadUrlForLayerError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetDownloadUrlForLayerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetDownloadUrlForLayerError {
fn from(err: serde_json::error::Error) -> GetDownloadUrlForLayerError {
GetDownloadUrlForLayerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetDownloadUrlForLayerError {
fn from(err: CredentialsError) -> GetDownloadUrlForLayerError {
GetDownloadUrlForLayerError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetDownloadUrlForLayerError {
fn from(err: HttpDispatchError) -> GetDownloadUrlForLayerError {
GetDownloadUrlForLayerError::HttpDispatch(err)
}
}
impl From<io::Error> for GetDownloadUrlForLayerError {
fn from(err: io::Error) -> GetDownloadUrlForLayerError {
GetDownloadUrlForLayerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetDownloadUrlForLayerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetDownloadUrlForLayerError {
fn description(&self) -> &str {
match *self {
GetDownloadUrlForLayerError::InvalidParameter(ref cause) => cause,
GetDownloadUrlForLayerError::LayerInaccessible(ref cause) => cause,
GetDownloadUrlForLayerError::LayersNotFound(ref cause) => cause,
GetDownloadUrlForLayerError::RepositoryNotFound(ref cause) => cause,
GetDownloadUrlForLayerError::Server(ref cause) => cause,
GetDownloadUrlForLayerError::Validation(ref cause) => cause,
GetDownloadUrlForLayerError::Credentials(ref err) => err.description(),
GetDownloadUrlForLayerError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetDownloadUrlForLayerError::ParseError(ref cause) => cause,
GetDownloadUrlForLayerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetLifecyclePolicyError {
InvalidParameter(String),
LifecyclePolicyNotFound(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetLifecyclePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> GetLifecyclePolicyError {
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 {
"InvalidParameterException" => {
return GetLifecyclePolicyError::InvalidParameter(String::from(error_message));
}
"LifecyclePolicyNotFoundException" => {
return GetLifecyclePolicyError::LifecyclePolicyNotFound(String::from(
error_message,
));
}
"RepositoryNotFoundException" => {
return GetLifecyclePolicyError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => {
return GetLifecyclePolicyError::Server(String::from(error_message));
}
"ValidationException" => {
return GetLifecyclePolicyError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetLifecyclePolicyError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetLifecyclePolicyError {
fn from(err: serde_json::error::Error) -> GetLifecyclePolicyError {
GetLifecyclePolicyError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetLifecyclePolicyError {
fn from(err: CredentialsError) -> GetLifecyclePolicyError {
GetLifecyclePolicyError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetLifecyclePolicyError {
fn from(err: HttpDispatchError) -> GetLifecyclePolicyError {
GetLifecyclePolicyError::HttpDispatch(err)
}
}
impl From<io::Error> for GetLifecyclePolicyError {
fn from(err: io::Error) -> GetLifecyclePolicyError {
GetLifecyclePolicyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetLifecyclePolicyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetLifecyclePolicyError {
fn description(&self) -> &str {
match *self {
GetLifecyclePolicyError::InvalidParameter(ref cause) => cause,
GetLifecyclePolicyError::LifecyclePolicyNotFound(ref cause) => cause,
GetLifecyclePolicyError::RepositoryNotFound(ref cause) => cause,
GetLifecyclePolicyError::Server(ref cause) => cause,
GetLifecyclePolicyError::Validation(ref cause) => cause,
GetLifecyclePolicyError::Credentials(ref err) => err.description(),
GetLifecyclePolicyError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetLifecyclePolicyError::ParseError(ref cause) => cause,
GetLifecyclePolicyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetLifecyclePolicyPreviewError {
InvalidParameter(String),
LifecyclePolicyPreviewNotFound(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetLifecyclePolicyPreviewError {
pub fn from_response(res: BufferedHttpResponse) -> GetLifecyclePolicyPreviewError {
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 {
"InvalidParameterException" => {
return GetLifecyclePolicyPreviewError::InvalidParameter(String::from(
error_message,
));
}
"LifecyclePolicyPreviewNotFoundException" => {
return GetLifecyclePolicyPreviewError::LifecyclePolicyPreviewNotFound(
String::from(error_message),
);
}
"RepositoryNotFoundException" => {
return GetLifecyclePolicyPreviewError::RepositoryNotFound(String::from(
error_message,
));
}
"ServerException" => {
return GetLifecyclePolicyPreviewError::Server(String::from(error_message));
}
"ValidationException" => {
return GetLifecyclePolicyPreviewError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetLifecyclePolicyPreviewError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetLifecyclePolicyPreviewError {
fn from(err: serde_json::error::Error) -> GetLifecyclePolicyPreviewError {
GetLifecyclePolicyPreviewError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetLifecyclePolicyPreviewError {
fn from(err: CredentialsError) -> GetLifecyclePolicyPreviewError {
GetLifecyclePolicyPreviewError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetLifecyclePolicyPreviewError {
fn from(err: HttpDispatchError) -> GetLifecyclePolicyPreviewError {
GetLifecyclePolicyPreviewError::HttpDispatch(err)
}
}
impl From<io::Error> for GetLifecyclePolicyPreviewError {
fn from(err: io::Error) -> GetLifecyclePolicyPreviewError {
GetLifecyclePolicyPreviewError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetLifecyclePolicyPreviewError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetLifecyclePolicyPreviewError {
fn description(&self) -> &str {
match *self {
GetLifecyclePolicyPreviewError::InvalidParameter(ref cause) => cause,
GetLifecyclePolicyPreviewError::LifecyclePolicyPreviewNotFound(ref cause) => cause,
GetLifecyclePolicyPreviewError::RepositoryNotFound(ref cause) => cause,
GetLifecyclePolicyPreviewError::Server(ref cause) => cause,
GetLifecyclePolicyPreviewError::Validation(ref cause) => cause,
GetLifecyclePolicyPreviewError::Credentials(ref err) => err.description(),
GetLifecyclePolicyPreviewError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetLifecyclePolicyPreviewError::ParseError(ref cause) => cause,
GetLifecyclePolicyPreviewError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetRepositoryPolicyError {
InvalidParameter(String),
RepositoryNotFound(String),
RepositoryPolicyNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetRepositoryPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> GetRepositoryPolicyError {
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 {
"InvalidParameterException" => {
return GetRepositoryPolicyError::InvalidParameter(String::from(error_message));
}
"RepositoryNotFoundException" => {
return GetRepositoryPolicyError::RepositoryNotFound(String::from(error_message));
}
"RepositoryPolicyNotFoundException" => {
return GetRepositoryPolicyError::RepositoryPolicyNotFound(String::from(
error_message,
));
}
"ServerException" => {
return GetRepositoryPolicyError::Server(String::from(error_message));
}
"ValidationException" => {
return GetRepositoryPolicyError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetRepositoryPolicyError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetRepositoryPolicyError {
fn from(err: serde_json::error::Error) -> GetRepositoryPolicyError {
GetRepositoryPolicyError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetRepositoryPolicyError {
fn from(err: CredentialsError) -> GetRepositoryPolicyError {
GetRepositoryPolicyError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetRepositoryPolicyError {
fn from(err: HttpDispatchError) -> GetRepositoryPolicyError {
GetRepositoryPolicyError::HttpDispatch(err)
}
}
impl From<io::Error> for GetRepositoryPolicyError {
fn from(err: io::Error) -> GetRepositoryPolicyError {
GetRepositoryPolicyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetRepositoryPolicyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetRepositoryPolicyError {
fn description(&self) -> &str {
match *self {
GetRepositoryPolicyError::InvalidParameter(ref cause) => cause,
GetRepositoryPolicyError::RepositoryNotFound(ref cause) => cause,
GetRepositoryPolicyError::RepositoryPolicyNotFound(ref cause) => cause,
GetRepositoryPolicyError::Server(ref cause) => cause,
GetRepositoryPolicyError::Validation(ref cause) => cause,
GetRepositoryPolicyError::Credentials(ref err) => err.description(),
GetRepositoryPolicyError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetRepositoryPolicyError::ParseError(ref cause) => cause,
GetRepositoryPolicyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum InitiateLayerUploadError {
InvalidParameter(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl InitiateLayerUploadError {
pub fn from_response(res: BufferedHttpResponse) -> InitiateLayerUploadError {
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 {
"InvalidParameterException" => {
return InitiateLayerUploadError::InvalidParameter(String::from(error_message));
}
"RepositoryNotFoundException" => {
return InitiateLayerUploadError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => {
return InitiateLayerUploadError::Server(String::from(error_message));
}
"ValidationException" => {
return InitiateLayerUploadError::Validation(error_message.to_string());
}
_ => {}
}
}
return InitiateLayerUploadError::Unknown(res);
}
}
impl From<serde_json::error::Error> for InitiateLayerUploadError {
fn from(err: serde_json::error::Error) -> InitiateLayerUploadError {
InitiateLayerUploadError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for InitiateLayerUploadError {
fn from(err: CredentialsError) -> InitiateLayerUploadError {
InitiateLayerUploadError::Credentials(err)
}
}
impl From<HttpDispatchError> for InitiateLayerUploadError {
fn from(err: HttpDispatchError) -> InitiateLayerUploadError {
InitiateLayerUploadError::HttpDispatch(err)
}
}
impl From<io::Error> for InitiateLayerUploadError {
fn from(err: io::Error) -> InitiateLayerUploadError {
InitiateLayerUploadError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for InitiateLayerUploadError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for InitiateLayerUploadError {
fn description(&self) -> &str {
match *self {
InitiateLayerUploadError::InvalidParameter(ref cause) => cause,
InitiateLayerUploadError::RepositoryNotFound(ref cause) => cause,
InitiateLayerUploadError::Server(ref cause) => cause,
InitiateLayerUploadError::Validation(ref cause) => cause,
InitiateLayerUploadError::Credentials(ref err) => err.description(),
InitiateLayerUploadError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
InitiateLayerUploadError::ParseError(ref cause) => cause,
InitiateLayerUploadError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListImagesError {
InvalidParameter(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListImagesError {
pub fn from_response(res: BufferedHttpResponse) -> ListImagesError {
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 {
"InvalidParameterException" => {
return ListImagesError::InvalidParameter(String::from(error_message));
}
"RepositoryNotFoundException" => {
return ListImagesError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => return ListImagesError::Server(String::from(error_message)),
"ValidationException" => {
return ListImagesError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListImagesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListImagesError {
fn from(err: serde_json::error::Error) -> ListImagesError {
ListImagesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListImagesError {
fn from(err: CredentialsError) -> ListImagesError {
ListImagesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListImagesError {
fn from(err: HttpDispatchError) -> ListImagesError {
ListImagesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListImagesError {
fn from(err: io::Error) -> ListImagesError {
ListImagesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListImagesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListImagesError {
fn description(&self) -> &str {
match *self {
ListImagesError::InvalidParameter(ref cause) => cause,
ListImagesError::RepositoryNotFound(ref cause) => cause,
ListImagesError::Server(ref cause) => cause,
ListImagesError::Validation(ref cause) => cause,
ListImagesError::Credentials(ref err) => err.description(),
ListImagesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListImagesError::ParseError(ref cause) => cause,
ListImagesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InvalidParameter(String),
RepositoryNotFound(String),
Server(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 {
"InvalidParameterException" => {
return ListTagsForResourceError::InvalidParameter(String::from(error_message));
}
"RepositoryNotFoundException" => {
return ListTagsForResourceError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => {
return ListTagsForResourceError::Server(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::InvalidParameter(ref cause) => cause,
ListTagsForResourceError::RepositoryNotFound(ref cause) => cause,
ListTagsForResourceError::Server(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 PutImageError {
ImageAlreadyExists(String),
InvalidParameter(String),
LayersNotFound(String),
LimitExceeded(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PutImageError {
pub fn from_response(res: BufferedHttpResponse) -> PutImageError {
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 {
"ImageAlreadyExistsException" => {
return PutImageError::ImageAlreadyExists(String::from(error_message));
}
"InvalidParameterException" => {
return PutImageError::InvalidParameter(String::from(error_message));
}
"LayersNotFoundException" => {
return PutImageError::LayersNotFound(String::from(error_message));
}
"LimitExceededException" => {
return PutImageError::LimitExceeded(String::from(error_message));
}
"RepositoryNotFoundException" => {
return PutImageError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => return PutImageError::Server(String::from(error_message)),
"ValidationException" => {
return PutImageError::Validation(error_message.to_string());
}
_ => {}
}
}
return PutImageError::Unknown(res);
}
}
impl From<serde_json::error::Error> for PutImageError {
fn from(err: serde_json::error::Error) -> PutImageError {
PutImageError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for PutImageError {
fn from(err: CredentialsError) -> PutImageError {
PutImageError::Credentials(err)
}
}
impl From<HttpDispatchError> for PutImageError {
fn from(err: HttpDispatchError) -> PutImageError {
PutImageError::HttpDispatch(err)
}
}
impl From<io::Error> for PutImageError {
fn from(err: io::Error) -> PutImageError {
PutImageError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PutImageError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PutImageError {
fn description(&self) -> &str {
match *self {
PutImageError::ImageAlreadyExists(ref cause) => cause,
PutImageError::InvalidParameter(ref cause) => cause,
PutImageError::LayersNotFound(ref cause) => cause,
PutImageError::LimitExceeded(ref cause) => cause,
PutImageError::RepositoryNotFound(ref cause) => cause,
PutImageError::Server(ref cause) => cause,
PutImageError::Validation(ref cause) => cause,
PutImageError::Credentials(ref err) => err.description(),
PutImageError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
PutImageError::ParseError(ref cause) => cause,
PutImageError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum PutLifecyclePolicyError {
InvalidParameter(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PutLifecyclePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> PutLifecyclePolicyError {
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 {
"InvalidParameterException" => {
return PutLifecyclePolicyError::InvalidParameter(String::from(error_message));
}
"RepositoryNotFoundException" => {
return PutLifecyclePolicyError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => {
return PutLifecyclePolicyError::Server(String::from(error_message));
}
"ValidationException" => {
return PutLifecyclePolicyError::Validation(error_message.to_string());
}
_ => {}
}
}
return PutLifecyclePolicyError::Unknown(res);
}
}
impl From<serde_json::error::Error> for PutLifecyclePolicyError {
fn from(err: serde_json::error::Error) -> PutLifecyclePolicyError {
PutLifecyclePolicyError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for PutLifecyclePolicyError {
fn from(err: CredentialsError) -> PutLifecyclePolicyError {
PutLifecyclePolicyError::Credentials(err)
}
}
impl From<HttpDispatchError> for PutLifecyclePolicyError {
fn from(err: HttpDispatchError) -> PutLifecyclePolicyError {
PutLifecyclePolicyError::HttpDispatch(err)
}
}
impl From<io::Error> for PutLifecyclePolicyError {
fn from(err: io::Error) -> PutLifecyclePolicyError {
PutLifecyclePolicyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PutLifecyclePolicyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PutLifecyclePolicyError {
fn description(&self) -> &str {
match *self {
PutLifecyclePolicyError::InvalidParameter(ref cause) => cause,
PutLifecyclePolicyError::RepositoryNotFound(ref cause) => cause,
PutLifecyclePolicyError::Server(ref cause) => cause,
PutLifecyclePolicyError::Validation(ref cause) => cause,
PutLifecyclePolicyError::Credentials(ref err) => err.description(),
PutLifecyclePolicyError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
PutLifecyclePolicyError::ParseError(ref cause) => cause,
PutLifecyclePolicyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum SetRepositoryPolicyError {
InvalidParameter(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl SetRepositoryPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> SetRepositoryPolicyError {
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 {
"InvalidParameterException" => {
return SetRepositoryPolicyError::InvalidParameter(String::from(error_message));
}
"RepositoryNotFoundException" => {
return SetRepositoryPolicyError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => {
return SetRepositoryPolicyError::Server(String::from(error_message));
}
"ValidationException" => {
return SetRepositoryPolicyError::Validation(error_message.to_string());
}
_ => {}
}
}
return SetRepositoryPolicyError::Unknown(res);
}
}
impl From<serde_json::error::Error> for SetRepositoryPolicyError {
fn from(err: serde_json::error::Error) -> SetRepositoryPolicyError {
SetRepositoryPolicyError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for SetRepositoryPolicyError {
fn from(err: CredentialsError) -> SetRepositoryPolicyError {
SetRepositoryPolicyError::Credentials(err)
}
}
impl From<HttpDispatchError> for SetRepositoryPolicyError {
fn from(err: HttpDispatchError) -> SetRepositoryPolicyError {
SetRepositoryPolicyError::HttpDispatch(err)
}
}
impl From<io::Error> for SetRepositoryPolicyError {
fn from(err: io::Error) -> SetRepositoryPolicyError {
SetRepositoryPolicyError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for SetRepositoryPolicyError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for SetRepositoryPolicyError {
fn description(&self) -> &str {
match *self {
SetRepositoryPolicyError::InvalidParameter(ref cause) => cause,
SetRepositoryPolicyError::RepositoryNotFound(ref cause) => cause,
SetRepositoryPolicyError::Server(ref cause) => cause,
SetRepositoryPolicyError::Validation(ref cause) => cause,
SetRepositoryPolicyError::Credentials(ref err) => err.description(),
SetRepositoryPolicyError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
SetRepositoryPolicyError::ParseError(ref cause) => cause,
SetRepositoryPolicyError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartLifecyclePolicyPreviewError {
InvalidParameter(String),
LifecyclePolicyNotFound(String),
LifecyclePolicyPreviewInProgress(String),
RepositoryNotFound(String),
Server(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartLifecyclePolicyPreviewError {
pub fn from_response(res: BufferedHttpResponse) -> StartLifecyclePolicyPreviewError {
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 {
"InvalidParameterException" => {
return StartLifecyclePolicyPreviewError::InvalidParameter(String::from(
error_message,
));
}
"LifecyclePolicyNotFoundException" => {
return StartLifecyclePolicyPreviewError::LifecyclePolicyNotFound(String::from(
error_message,
));
}
"LifecyclePolicyPreviewInProgressException" => {
return StartLifecyclePolicyPreviewError::LifecyclePolicyPreviewInProgress(
String::from(error_message),
);
}
"RepositoryNotFoundException" => {
return StartLifecyclePolicyPreviewError::RepositoryNotFound(String::from(
error_message,
));
}
"ServerException" => {
return StartLifecyclePolicyPreviewError::Server(String::from(error_message));
}
"ValidationException" => {
return StartLifecyclePolicyPreviewError::Validation(error_message.to_string());
}
_ => {}
}
}
return StartLifecyclePolicyPreviewError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartLifecyclePolicyPreviewError {
fn from(err: serde_json::error::Error) -> StartLifecyclePolicyPreviewError {
StartLifecyclePolicyPreviewError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartLifecyclePolicyPreviewError {
fn from(err: CredentialsError) -> StartLifecyclePolicyPreviewError {
StartLifecyclePolicyPreviewError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartLifecyclePolicyPreviewError {
fn from(err: HttpDispatchError) -> StartLifecyclePolicyPreviewError {
StartLifecyclePolicyPreviewError::HttpDispatch(err)
}
}
impl From<io::Error> for StartLifecyclePolicyPreviewError {
fn from(err: io::Error) -> StartLifecyclePolicyPreviewError {
StartLifecyclePolicyPreviewError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartLifecyclePolicyPreviewError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartLifecyclePolicyPreviewError {
fn description(&self) -> &str {
match *self {
StartLifecyclePolicyPreviewError::InvalidParameter(ref cause) => cause,
StartLifecyclePolicyPreviewError::LifecyclePolicyNotFound(ref cause) => cause,
StartLifecyclePolicyPreviewError::LifecyclePolicyPreviewInProgress(ref cause) => cause,
StartLifecyclePolicyPreviewError::RepositoryNotFound(ref cause) => cause,
StartLifecyclePolicyPreviewError::Server(ref cause) => cause,
StartLifecyclePolicyPreviewError::Validation(ref cause) => cause,
StartLifecyclePolicyPreviewError::Credentials(ref err) => err.description(),
StartLifecyclePolicyPreviewError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
StartLifecyclePolicyPreviewError::ParseError(ref cause) => cause,
StartLifecyclePolicyPreviewError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InvalidParameter(String),
InvalidTagParameter(String),
RepositoryNotFound(String),
Server(String),
TooManyTags(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 {
"InvalidParameterException" => {
return TagResourceError::InvalidParameter(String::from(error_message));
}
"InvalidTagParameterException" => {
return TagResourceError::InvalidTagParameter(String::from(error_message));
}
"RepositoryNotFoundException" => {
return TagResourceError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => return TagResourceError::Server(String::from(error_message)),
"TooManyTagsException" => {
return TagResourceError::TooManyTags(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::InvalidParameter(ref cause) => cause,
TagResourceError::InvalidTagParameter(ref cause) => cause,
TagResourceError::RepositoryNotFound(ref cause) => cause,
TagResourceError::Server(ref cause) => cause,
TagResourceError::TooManyTags(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 {
InvalidParameter(String),
InvalidTagParameter(String),
RepositoryNotFound(String),
Server(String),
TooManyTags(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 {
"InvalidParameterException" => {
return UntagResourceError::InvalidParameter(String::from(error_message));
}
"InvalidTagParameterException" => {
return UntagResourceError::InvalidTagParameter(String::from(error_message));
}
"RepositoryNotFoundException" => {
return UntagResourceError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => return UntagResourceError::Server(String::from(error_message)),
"TooManyTagsException" => {
return UntagResourceError::TooManyTags(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::InvalidParameter(ref cause) => cause,
UntagResourceError::InvalidTagParameter(ref cause) => cause,
UntagResourceError::RepositoryNotFound(ref cause) => cause,
UntagResourceError::Server(ref cause) => cause,
UntagResourceError::TooManyTags(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 UploadLayerPartError {
InvalidLayerPart(String),
InvalidParameter(String),
LimitExceeded(String),
RepositoryNotFound(String),
Server(String),
UploadNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UploadLayerPartError {
pub fn from_response(res: BufferedHttpResponse) -> UploadLayerPartError {
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 {
"InvalidLayerPartException" => {
return UploadLayerPartError::InvalidLayerPart(String::from(error_message));
}
"InvalidParameterException" => {
return UploadLayerPartError::InvalidParameter(String::from(error_message));
}
"LimitExceededException" => {
return UploadLayerPartError::LimitExceeded(String::from(error_message));
}
"RepositoryNotFoundException" => {
return UploadLayerPartError::RepositoryNotFound(String::from(error_message));
}
"ServerException" => {
return UploadLayerPartError::Server(String::from(error_message));
}
"UploadNotFoundException" => {
return UploadLayerPartError::UploadNotFound(String::from(error_message));
}
"ValidationException" => {
return UploadLayerPartError::Validation(error_message.to_string());
}
_ => {}
}
}
return UploadLayerPartError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UploadLayerPartError {
fn from(err: serde_json::error::Error) -> UploadLayerPartError {
UploadLayerPartError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UploadLayerPartError {
fn from(err: CredentialsError) -> UploadLayerPartError {
UploadLayerPartError::Credentials(err)
}
}
impl From<HttpDispatchError> for UploadLayerPartError {
fn from(err: HttpDispatchError) -> UploadLayerPartError {
UploadLayerPartError::HttpDispatch(err)
}
}
impl From<io::Error> for UploadLayerPartError {
fn from(err: io::Error) -> UploadLayerPartError {
UploadLayerPartError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UploadLayerPartError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UploadLayerPartError {
fn description(&self) -> &str {
match *self {
UploadLayerPartError::InvalidLayerPart(ref cause) => cause,
UploadLayerPartError::InvalidParameter(ref cause) => cause,
UploadLayerPartError::LimitExceeded(ref cause) => cause,
UploadLayerPartError::RepositoryNotFound(ref cause) => cause,
UploadLayerPartError::Server(ref cause) => cause,
UploadLayerPartError::UploadNotFound(ref cause) => cause,
UploadLayerPartError::Validation(ref cause) => cause,
UploadLayerPartError::Credentials(ref err) => err.description(),
UploadLayerPartError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UploadLayerPartError::ParseError(ref cause) => cause,
UploadLayerPartError::Unknown(_) => "unknown error",
}
}
}
pub trait Ecr {
fn batch_check_layer_availability(
&self,
input: BatchCheckLayerAvailabilityRequest,
) -> RusotoFuture<BatchCheckLayerAvailabilityResponse, BatchCheckLayerAvailabilityError>;
fn batch_delete_image(
&self,
input: BatchDeleteImageRequest,
) -> RusotoFuture<BatchDeleteImageResponse, BatchDeleteImageError>;
fn batch_get_image(
&self,
input: BatchGetImageRequest,
) -> RusotoFuture<BatchGetImageResponse, BatchGetImageError>;
fn complete_layer_upload(
&self,
input: CompleteLayerUploadRequest,
) -> RusotoFuture<CompleteLayerUploadResponse, CompleteLayerUploadError>;
fn create_repository(
&self,
input: CreateRepositoryRequest,
) -> RusotoFuture<CreateRepositoryResponse, CreateRepositoryError>;
fn delete_lifecycle_policy(
&self,
input: DeleteLifecyclePolicyRequest,
) -> RusotoFuture<DeleteLifecyclePolicyResponse, DeleteLifecyclePolicyError>;
fn delete_repository(
&self,
input: DeleteRepositoryRequest,
) -> RusotoFuture<DeleteRepositoryResponse, DeleteRepositoryError>;
fn delete_repository_policy(
&self,
input: DeleteRepositoryPolicyRequest,
) -> RusotoFuture<DeleteRepositoryPolicyResponse, DeleteRepositoryPolicyError>;
fn describe_images(
&self,
input: DescribeImagesRequest,
) -> RusotoFuture<DescribeImagesResponse, DescribeImagesError>;
fn describe_repositories(
&self,
input: DescribeRepositoriesRequest,
) -> RusotoFuture<DescribeRepositoriesResponse, DescribeRepositoriesError>;
fn get_authorization_token(
&self,
input: GetAuthorizationTokenRequest,
) -> RusotoFuture<GetAuthorizationTokenResponse, GetAuthorizationTokenError>;
fn get_download_url_for_layer(
&self,
input: GetDownloadUrlForLayerRequest,
) -> RusotoFuture<GetDownloadUrlForLayerResponse, GetDownloadUrlForLayerError>;
fn get_lifecycle_policy(
&self,
input: GetLifecyclePolicyRequest,
) -> RusotoFuture<GetLifecyclePolicyResponse, GetLifecyclePolicyError>;
fn get_lifecycle_policy_preview(
&self,
input: GetLifecyclePolicyPreviewRequest,
) -> RusotoFuture<GetLifecyclePolicyPreviewResponse, GetLifecyclePolicyPreviewError>;
fn get_repository_policy(
&self,
input: GetRepositoryPolicyRequest,
) -> RusotoFuture<GetRepositoryPolicyResponse, GetRepositoryPolicyError>;
fn initiate_layer_upload(
&self,
input: InitiateLayerUploadRequest,
) -> RusotoFuture<InitiateLayerUploadResponse, InitiateLayerUploadError>;
fn list_images(
&self,
input: ListImagesRequest,
) -> RusotoFuture<ListImagesResponse, ListImagesError>;
fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> RusotoFuture<ListTagsForResourceResponse, ListTagsForResourceError>;
fn put_image(&self, input: PutImageRequest) -> RusotoFuture<PutImageResponse, PutImageError>;
fn put_lifecycle_policy(
&self,
input: PutLifecyclePolicyRequest,
) -> RusotoFuture<PutLifecyclePolicyResponse, PutLifecyclePolicyError>;
fn set_repository_policy(
&self,
input: SetRepositoryPolicyRequest,
) -> RusotoFuture<SetRepositoryPolicyResponse, SetRepositoryPolicyError>;
fn start_lifecycle_policy_preview(
&self,
input: StartLifecyclePolicyPreviewRequest,
) -> RusotoFuture<StartLifecyclePolicyPreviewResponse, StartLifecyclePolicyPreviewError>;
fn tag_resource(
&self,
input: TagResourceRequest,
) -> RusotoFuture<TagResourceResponse, TagResourceError>;
fn untag_resource(
&self,
input: UntagResourceRequest,
) -> RusotoFuture<UntagResourceResponse, UntagResourceError>;
fn upload_layer_part(
&self,
input: UploadLayerPartRequest,
) -> RusotoFuture<UploadLayerPartResponse, UploadLayerPartError>;
}
#[derive(Clone)]
pub struct EcrClient {
client: Client,
region: region::Region,
}
impl EcrClient {
pub fn new(region: region::Region) -> EcrClient {
EcrClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> EcrClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
EcrClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl Ecr for EcrClient {
fn batch_check_layer_availability(
&self,
input: BatchCheckLayerAvailabilityRequest,
) -> RusotoFuture<BatchCheckLayerAvailabilityResponse, BatchCheckLayerAvailabilityError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.BatchCheckLayerAvailability",
);
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::<BatchCheckLayerAvailabilityResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(BatchCheckLayerAvailabilityError::from_response(response))
}))
}
})
}
fn batch_delete_image(
&self,
input: BatchDeleteImageRequest,
) -> RusotoFuture<BatchDeleteImageResponse, BatchDeleteImageError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.BatchDeleteImage",
);
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::<BatchDeleteImageResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(BatchDeleteImageError::from_response(response))),
)
}
})
}
fn batch_get_image(
&self,
input: BatchGetImageRequest,
) -> RusotoFuture<BatchGetImageResponse, BatchGetImageError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.BatchGetImage",
);
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::<BatchGetImageResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(BatchGetImageError::from_response(response))),
)
}
})
}
fn complete_layer_upload(
&self,
input: CompleteLayerUploadRequest,
) -> RusotoFuture<CompleteLayerUploadResponse, CompleteLayerUploadError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.CompleteLayerUpload",
);
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::<CompleteLayerUploadResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(CompleteLayerUploadError::from_response(response))
}),
)
}
})
}
fn create_repository(
&self,
input: CreateRepositoryRequest,
) -> RusotoFuture<CreateRepositoryResponse, CreateRepositoryError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.CreateRepository",
);
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::<CreateRepositoryResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateRepositoryError::from_response(response))),
)
}
})
}
fn delete_lifecycle_policy(
&self,
input: DeleteLifecyclePolicyRequest,
) -> RusotoFuture<DeleteLifecyclePolicyResponse, DeleteLifecyclePolicyError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.DeleteLifecyclePolicy",
);
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::<DeleteLifecyclePolicyResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteLifecyclePolicyError::from_response(response))
}),
)
}
})
}
fn delete_repository(
&self,
input: DeleteRepositoryRequest,
) -> RusotoFuture<DeleteRepositoryResponse, DeleteRepositoryError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.DeleteRepository",
);
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::<DeleteRepositoryResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteRepositoryError::from_response(response))),
)
}
})
}
fn delete_repository_policy(
&self,
input: DeleteRepositoryPolicyRequest,
) -> RusotoFuture<DeleteRepositoryPolicyResponse, DeleteRepositoryPolicyError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.DeleteRepositoryPolicy",
);
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::<DeleteRepositoryPolicyResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteRepositoryPolicyError::from_response(response))
}),
)
}
})
}
fn describe_images(
&self,
input: DescribeImagesRequest,
) -> RusotoFuture<DescribeImagesResponse, DescribeImagesError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.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::<DescribeImagesResponse>(
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_repositories(
&self,
input: DescribeRepositoriesRequest,
) -> RusotoFuture<DescribeRepositoriesResponse, DescribeRepositoriesError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.DescribeRepositories",
);
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::<DescribeRepositoriesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeRepositoriesError::from_response(response))
}),
)
}
})
}
fn get_authorization_token(
&self,
input: GetAuthorizationTokenRequest,
) -> RusotoFuture<GetAuthorizationTokenResponse, GetAuthorizationTokenError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.GetAuthorizationToken",
);
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::<GetAuthorizationTokenResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetAuthorizationTokenError::from_response(response))
}),
)
}
})
}
fn get_download_url_for_layer(
&self,
input: GetDownloadUrlForLayerRequest,
) -> RusotoFuture<GetDownloadUrlForLayerResponse, GetDownloadUrlForLayerError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.GetDownloadUrlForLayer",
);
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::<GetDownloadUrlForLayerResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetDownloadUrlForLayerError::from_response(response))
}),
)
}
})
}
fn get_lifecycle_policy(
&self,
input: GetLifecyclePolicyRequest,
) -> RusotoFuture<GetLifecyclePolicyResponse, GetLifecyclePolicyError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.GetLifecyclePolicy",
);
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::<GetLifecyclePolicyResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetLifecyclePolicyError::from_response(response))),
)
}
})
}
fn get_lifecycle_policy_preview(
&self,
input: GetLifecyclePolicyPreviewRequest,
) -> RusotoFuture<GetLifecyclePolicyPreviewResponse, GetLifecyclePolicyPreviewError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.GetLifecyclePolicyPreview",
);
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::<GetLifecyclePolicyPreviewResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetLifecyclePolicyPreviewError::from_response(response))
}))
}
})
}
fn get_repository_policy(
&self,
input: GetRepositoryPolicyRequest,
) -> RusotoFuture<GetRepositoryPolicyResponse, GetRepositoryPolicyError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.GetRepositoryPolicy",
);
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::<GetRepositoryPolicyResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetRepositoryPolicyError::from_response(response))
}),
)
}
})
}
fn initiate_layer_upload(
&self,
input: InitiateLayerUploadRequest,
) -> RusotoFuture<InitiateLayerUploadResponse, InitiateLayerUploadError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.InitiateLayerUpload",
);
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::<InitiateLayerUploadResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(InitiateLayerUploadError::from_response(response))
}),
)
}
})
}
fn list_images(
&self,
input: ListImagesRequest,
) -> RusotoFuture<ListImagesResponse, ListImagesError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.ListImages",
);
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::<ListImagesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListImagesError::from_response(response))),
)
}
})
}
fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> RusotoFuture<ListTagsForResourceResponse, ListTagsForResourceError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.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 put_image(&self, input: PutImageRequest) -> RusotoFuture<PutImageResponse, PutImageError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.PutImage",
);
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::<PutImageResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(PutImageError::from_response(response))),
)
}
})
}
fn put_lifecycle_policy(
&self,
input: PutLifecyclePolicyRequest,
) -> RusotoFuture<PutLifecyclePolicyResponse, PutLifecyclePolicyError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.PutLifecyclePolicy",
);
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::<PutLifecyclePolicyResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(PutLifecyclePolicyError::from_response(response))),
)
}
})
}
fn set_repository_policy(
&self,
input: SetRepositoryPolicyRequest,
) -> RusotoFuture<SetRepositoryPolicyResponse, SetRepositoryPolicyError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.SetRepositoryPolicy",
);
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::<SetRepositoryPolicyResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(SetRepositoryPolicyError::from_response(response))
}),
)
}
})
}
fn start_lifecycle_policy_preview(
&self,
input: StartLifecyclePolicyPreviewRequest,
) -> RusotoFuture<StartLifecyclePolicyPreviewResponse, StartLifecyclePolicyPreviewError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.StartLifecyclePolicyPreview",
);
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::<StartLifecyclePolicyPreviewResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(StartLifecyclePolicyPreviewError::from_response(response))
}))
}
})
}
fn tag_resource(
&self,
input: TagResourceRequest,
) -> RusotoFuture<TagResourceResponse, TagResourceError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.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", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.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 upload_layer_part(
&self,
input: UploadLayerPartRequest,
) -> RusotoFuture<UploadLayerPartResponse, UploadLayerPartError> {
let mut request = SignedRequest::new("POST", "ecr", &self.region, "/");
request.set_endpoint_prefix("api.ecr".to_string());
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"AmazonEC2ContainerRegistry_V20150921.UploadLayerPart",
);
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::<UploadLayerPartResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UploadLayerPartError::from_response(response))),
)
}
})
}
}
#[cfg(test)]
mod protocol_tests {}