use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Container {
#[serde(rename = "ARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "AccessLoggingEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_logging_enabled: Option<bool>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "Endpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub 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 CorsRule {
#[serde(rename = "AllowedHeaders")]
pub allowed_headers: Vec<String>,
#[serde(rename = "AllowedMethods")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_methods: Option<Vec<String>>,
#[serde(rename = "AllowedOrigins")]
pub allowed_origins: Vec<String>,
#[serde(rename = "ExposeHeaders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expose_headers: Option<Vec<String>>,
#[serde(rename = "MaxAgeSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_age_seconds: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateContainerInput {
#[serde(rename = "ContainerName")]
pub container_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(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateContainerOutput {
#[serde(rename = "Container")]
pub container: Container,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteContainerInput {
#[serde(rename = "ContainerName")]
pub container_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteContainerOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteContainerPolicyInput {
#[serde(rename = "ContainerName")]
pub container_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteContainerPolicyOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCorsPolicyInput {
#[serde(rename = "ContainerName")]
pub container_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteCorsPolicyOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteLifecyclePolicyInput {
#[serde(rename = "ContainerName")]
pub container_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteLifecyclePolicyOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeContainerInput {
#[serde(rename = "ContainerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeContainerOutput {
#[serde(rename = "Container")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container: Option<Container>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetContainerPolicyInput {
#[serde(rename = "ContainerName")]
pub container_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetContainerPolicyOutput {
#[serde(rename = "Policy")]
pub policy: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCorsPolicyInput {
#[serde(rename = "ContainerName")]
pub container_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCorsPolicyOutput {
#[serde(rename = "CorsPolicy")]
pub cors_policy: Vec<CorsRule>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetLifecyclePolicyInput {
#[serde(rename = "ContainerName")]
pub container_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetLifecyclePolicyOutput {
#[serde(rename = "LifecyclePolicy")]
pub lifecycle_policy: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListContainersInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListContainersOutput {
#[serde(rename = "Containers")]
pub containers: Vec<Container>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceInput {
#[serde(rename = "Resource")]
pub resource: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceOutput {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutContainerPolicyInput {
#[serde(rename = "ContainerName")]
pub container_name: String,
#[serde(rename = "Policy")]
pub policy: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutContainerPolicyOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutCorsPolicyInput {
#[serde(rename = "ContainerName")]
pub container_name: String,
#[serde(rename = "CorsPolicy")]
pub cors_policy: Vec<CorsRule>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutCorsPolicyOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutLifecyclePolicyInput {
#[serde(rename = "ContainerName")]
pub container_name: String,
#[serde(rename = "LifecyclePolicy")]
pub lifecycle_policy: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutLifecyclePolicyOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartAccessLoggingInput {
#[serde(rename = "ContainerName")]
pub container_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartAccessLoggingOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopAccessLoggingInput {
#[serde(rename = "ContainerName")]
pub container_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopAccessLoggingOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Tag {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceInput {
#[serde(rename = "Resource")]
pub resource: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceInput {
#[serde(rename = "Resource")]
pub resource: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceOutput {}
#[derive(Debug, PartialEq)]
pub enum CreateContainerError {
ContainerInUse(String),
InternalServerError(String),
LimitExceeded(String),
}
impl CreateContainerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateContainerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(CreateContainerError::ContainerInUse(err.msg))
}
"InternalServerError" => {
return RusotoError::Service(CreateContainerError::InternalServerError(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateContainerError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateContainerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateContainerError::ContainerInUse(ref cause) => write!(f, "{}", cause),
CreateContainerError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateContainerError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateContainerError {}
#[derive(Debug, PartialEq)]
pub enum DeleteContainerError {
ContainerInUse(String),
ContainerNotFound(String),
InternalServerError(String),
}
impl DeleteContainerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteContainerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(DeleteContainerError::ContainerInUse(err.msg))
}
"ContainerNotFoundException" => {
return RusotoError::Service(DeleteContainerError::ContainerNotFound(err.msg))
}
"InternalServerError" => {
return RusotoError::Service(DeleteContainerError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteContainerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteContainerError::ContainerInUse(ref cause) => write!(f, "{}", cause),
DeleteContainerError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
DeleteContainerError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteContainerError {}
#[derive(Debug, PartialEq)]
pub enum DeleteContainerPolicyError {
ContainerInUse(String),
ContainerNotFound(String),
InternalServerError(String),
PolicyNotFound(String),
}
impl DeleteContainerPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteContainerPolicyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(DeleteContainerPolicyError::ContainerInUse(
err.msg,
))
}
"ContainerNotFoundException" => {
return RusotoError::Service(DeleteContainerPolicyError::ContainerNotFound(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(DeleteContainerPolicyError::InternalServerError(
err.msg,
))
}
"PolicyNotFoundException" => {
return RusotoError::Service(DeleteContainerPolicyError::PolicyNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteContainerPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteContainerPolicyError::ContainerInUse(ref cause) => write!(f, "{}", cause),
DeleteContainerPolicyError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
DeleteContainerPolicyError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteContainerPolicyError::PolicyNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteContainerPolicyError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCorsPolicyError {
ContainerInUse(String),
ContainerNotFound(String),
CorsPolicyNotFound(String),
InternalServerError(String),
}
impl DeleteCorsPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCorsPolicyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(DeleteCorsPolicyError::ContainerInUse(err.msg))
}
"ContainerNotFoundException" => {
return RusotoError::Service(DeleteCorsPolicyError::ContainerNotFound(err.msg))
}
"CorsPolicyNotFoundException" => {
return RusotoError::Service(DeleteCorsPolicyError::CorsPolicyNotFound(err.msg))
}
"InternalServerError" => {
return RusotoError::Service(DeleteCorsPolicyError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteCorsPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCorsPolicyError::ContainerInUse(ref cause) => write!(f, "{}", cause),
DeleteCorsPolicyError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
DeleteCorsPolicyError::CorsPolicyNotFound(ref cause) => write!(f, "{}", cause),
DeleteCorsPolicyError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteCorsPolicyError {}
#[derive(Debug, PartialEq)]
pub enum DeleteLifecyclePolicyError {
ContainerInUse(String),
ContainerNotFound(String),
InternalServerError(String),
PolicyNotFound(String),
}
impl DeleteLifecyclePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteLifecyclePolicyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(DeleteLifecyclePolicyError::ContainerInUse(
err.msg,
))
}
"ContainerNotFoundException" => {
return RusotoError::Service(DeleteLifecyclePolicyError::ContainerNotFound(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(DeleteLifecyclePolicyError::InternalServerError(
err.msg,
))
}
"PolicyNotFoundException" => {
return RusotoError::Service(DeleteLifecyclePolicyError::PolicyNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLifecyclePolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLifecyclePolicyError::ContainerInUse(ref cause) => write!(f, "{}", cause),
DeleteLifecyclePolicyError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
DeleteLifecyclePolicyError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteLifecyclePolicyError::PolicyNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteLifecyclePolicyError {}
#[derive(Debug, PartialEq)]
pub enum DescribeContainerError {
ContainerNotFound(String),
InternalServerError(String),
}
impl DescribeContainerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeContainerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerNotFoundException" => {
return RusotoError::Service(DescribeContainerError::ContainerNotFound(err.msg))
}
"InternalServerError" => {
return RusotoError::Service(DescribeContainerError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeContainerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeContainerError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
DescribeContainerError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeContainerError {}
#[derive(Debug, PartialEq)]
pub enum GetContainerPolicyError {
ContainerInUse(String),
ContainerNotFound(String),
InternalServerError(String),
PolicyNotFound(String),
}
impl GetContainerPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetContainerPolicyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(GetContainerPolicyError::ContainerInUse(err.msg))
}
"ContainerNotFoundException" => {
return RusotoError::Service(GetContainerPolicyError::ContainerNotFound(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(GetContainerPolicyError::InternalServerError(
err.msg,
))
}
"PolicyNotFoundException" => {
return RusotoError::Service(GetContainerPolicyError::PolicyNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetContainerPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetContainerPolicyError::ContainerInUse(ref cause) => write!(f, "{}", cause),
GetContainerPolicyError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
GetContainerPolicyError::InternalServerError(ref cause) => write!(f, "{}", cause),
GetContainerPolicyError::PolicyNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetContainerPolicyError {}
#[derive(Debug, PartialEq)]
pub enum GetCorsPolicyError {
ContainerInUse(String),
ContainerNotFound(String),
CorsPolicyNotFound(String),
InternalServerError(String),
}
impl GetCorsPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetCorsPolicyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(GetCorsPolicyError::ContainerInUse(err.msg))
}
"ContainerNotFoundException" => {
return RusotoError::Service(GetCorsPolicyError::ContainerNotFound(err.msg))
}
"CorsPolicyNotFoundException" => {
return RusotoError::Service(GetCorsPolicyError::CorsPolicyNotFound(err.msg))
}
"InternalServerError" => {
return RusotoError::Service(GetCorsPolicyError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCorsPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCorsPolicyError::ContainerInUse(ref cause) => write!(f, "{}", cause),
GetCorsPolicyError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
GetCorsPolicyError::CorsPolicyNotFound(ref cause) => write!(f, "{}", cause),
GetCorsPolicyError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetCorsPolicyError {}
#[derive(Debug, PartialEq)]
pub enum GetLifecyclePolicyError {
ContainerInUse(String),
ContainerNotFound(String),
InternalServerError(String),
PolicyNotFound(String),
}
impl GetLifecyclePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLifecyclePolicyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(GetLifecyclePolicyError::ContainerInUse(err.msg))
}
"ContainerNotFoundException" => {
return RusotoError::Service(GetLifecyclePolicyError::ContainerNotFound(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(GetLifecyclePolicyError::InternalServerError(
err.msg,
))
}
"PolicyNotFoundException" => {
return RusotoError::Service(GetLifecyclePolicyError::PolicyNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLifecyclePolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLifecyclePolicyError::ContainerInUse(ref cause) => write!(f, "{}", cause),
GetLifecyclePolicyError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
GetLifecyclePolicyError::InternalServerError(ref cause) => write!(f, "{}", cause),
GetLifecyclePolicyError::PolicyNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLifecyclePolicyError {}
#[derive(Debug, PartialEq)]
pub enum ListContainersError {
InternalServerError(String),
}
impl ListContainersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListContainersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(ListContainersError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListContainersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListContainersError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListContainersError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
ContainerInUse(String),
ContainerNotFound(String),
InternalServerError(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(ListTagsForResourceError::ContainerInUse(err.msg))
}
"ContainerNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ContainerNotFound(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(ListTagsForResourceError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::ContainerInUse(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum PutContainerPolicyError {
ContainerInUse(String),
ContainerNotFound(String),
InternalServerError(String),
}
impl PutContainerPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutContainerPolicyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(PutContainerPolicyError::ContainerInUse(err.msg))
}
"ContainerNotFoundException" => {
return RusotoError::Service(PutContainerPolicyError::ContainerNotFound(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(PutContainerPolicyError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutContainerPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutContainerPolicyError::ContainerInUse(ref cause) => write!(f, "{}", cause),
PutContainerPolicyError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
PutContainerPolicyError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutContainerPolicyError {}
#[derive(Debug, PartialEq)]
pub enum PutCorsPolicyError {
ContainerInUse(String),
ContainerNotFound(String),
InternalServerError(String),
}
impl PutCorsPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutCorsPolicyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(PutCorsPolicyError::ContainerInUse(err.msg))
}
"ContainerNotFoundException" => {
return RusotoError::Service(PutCorsPolicyError::ContainerNotFound(err.msg))
}
"InternalServerError" => {
return RusotoError::Service(PutCorsPolicyError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutCorsPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutCorsPolicyError::ContainerInUse(ref cause) => write!(f, "{}", cause),
PutCorsPolicyError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
PutCorsPolicyError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutCorsPolicyError {}
#[derive(Debug, PartialEq)]
pub enum PutLifecyclePolicyError {
ContainerInUse(String),
ContainerNotFound(String),
InternalServerError(String),
}
impl PutLifecyclePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutLifecyclePolicyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(PutLifecyclePolicyError::ContainerInUse(err.msg))
}
"ContainerNotFoundException" => {
return RusotoError::Service(PutLifecyclePolicyError::ContainerNotFound(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(PutLifecyclePolicyError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutLifecyclePolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutLifecyclePolicyError::ContainerInUse(ref cause) => write!(f, "{}", cause),
PutLifecyclePolicyError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
PutLifecyclePolicyError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutLifecyclePolicyError {}
#[derive(Debug, PartialEq)]
pub enum StartAccessLoggingError {
ContainerInUse(String),
ContainerNotFound(String),
InternalServerError(String),
}
impl StartAccessLoggingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartAccessLoggingError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(StartAccessLoggingError::ContainerInUse(err.msg))
}
"ContainerNotFoundException" => {
return RusotoError::Service(StartAccessLoggingError::ContainerNotFound(
err.msg,
))
}
"InternalServerError" => {
return RusotoError::Service(StartAccessLoggingError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartAccessLoggingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartAccessLoggingError::ContainerInUse(ref cause) => write!(f, "{}", cause),
StartAccessLoggingError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
StartAccessLoggingError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartAccessLoggingError {}
#[derive(Debug, PartialEq)]
pub enum StopAccessLoggingError {
ContainerInUse(String),
ContainerNotFound(String),
InternalServerError(String),
}
impl StopAccessLoggingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopAccessLoggingError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(StopAccessLoggingError::ContainerInUse(err.msg))
}
"ContainerNotFoundException" => {
return RusotoError::Service(StopAccessLoggingError::ContainerNotFound(err.msg))
}
"InternalServerError" => {
return RusotoError::Service(StopAccessLoggingError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopAccessLoggingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopAccessLoggingError::ContainerInUse(ref cause) => write!(f, "{}", cause),
StopAccessLoggingError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
StopAccessLoggingError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopAccessLoggingError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
ContainerInUse(String),
ContainerNotFound(String),
InternalServerError(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(TagResourceError::ContainerInUse(err.msg))
}
"ContainerNotFoundException" => {
return RusotoError::Service(TagResourceError::ContainerNotFound(err.msg))
}
"InternalServerError" => {
return RusotoError::Service(TagResourceError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::ContainerInUse(ref cause) => write!(f, "{}", cause),
TagResourceError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
ContainerInUse(String),
ContainerNotFound(String),
InternalServerError(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ContainerInUseException" => {
return RusotoError::Service(UntagResourceError::ContainerInUse(err.msg))
}
"ContainerNotFoundException" => {
return RusotoError::Service(UntagResourceError::ContainerNotFound(err.msg))
}
"InternalServerError" => {
return RusotoError::Service(UntagResourceError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::ContainerInUse(ref cause) => write!(f, "{}", cause),
UntagResourceError::ContainerNotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[async_trait]
pub trait MediaStore {
async fn create_container(
&self,
input: CreateContainerInput,
) -> Result<CreateContainerOutput, RusotoError<CreateContainerError>>;
async fn delete_container(
&self,
input: DeleteContainerInput,
) -> Result<DeleteContainerOutput, RusotoError<DeleteContainerError>>;
async fn delete_container_policy(
&self,
input: DeleteContainerPolicyInput,
) -> Result<DeleteContainerPolicyOutput, RusotoError<DeleteContainerPolicyError>>;
async fn delete_cors_policy(
&self,
input: DeleteCorsPolicyInput,
) -> Result<DeleteCorsPolicyOutput, RusotoError<DeleteCorsPolicyError>>;
async fn delete_lifecycle_policy(
&self,
input: DeleteLifecyclePolicyInput,
) -> Result<DeleteLifecyclePolicyOutput, RusotoError<DeleteLifecyclePolicyError>>;
async fn describe_container(
&self,
input: DescribeContainerInput,
) -> Result<DescribeContainerOutput, RusotoError<DescribeContainerError>>;
async fn get_container_policy(
&self,
input: GetContainerPolicyInput,
) -> Result<GetContainerPolicyOutput, RusotoError<GetContainerPolicyError>>;
async fn get_cors_policy(
&self,
input: GetCorsPolicyInput,
) -> Result<GetCorsPolicyOutput, RusotoError<GetCorsPolicyError>>;
async fn get_lifecycle_policy(
&self,
input: GetLifecyclePolicyInput,
) -> Result<GetLifecyclePolicyOutput, RusotoError<GetLifecyclePolicyError>>;
async fn list_containers(
&self,
input: ListContainersInput,
) -> Result<ListContainersOutput, RusotoError<ListContainersError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceInput,
) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>>;
async fn put_container_policy(
&self,
input: PutContainerPolicyInput,
) -> Result<PutContainerPolicyOutput, RusotoError<PutContainerPolicyError>>;
async fn put_cors_policy(
&self,
input: PutCorsPolicyInput,
) -> Result<PutCorsPolicyOutput, RusotoError<PutCorsPolicyError>>;
async fn put_lifecycle_policy(
&self,
input: PutLifecyclePolicyInput,
) -> Result<PutLifecyclePolicyOutput, RusotoError<PutLifecyclePolicyError>>;
async fn start_access_logging(
&self,
input: StartAccessLoggingInput,
) -> Result<StartAccessLoggingOutput, RusotoError<StartAccessLoggingError>>;
async fn stop_access_logging(
&self,
input: StopAccessLoggingInput,
) -> Result<StopAccessLoggingOutput, RusotoError<StopAccessLoggingError>>;
async fn tag_resource(
&self,
input: TagResourceInput,
) -> Result<TagResourceOutput, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceInput,
) -> Result<UntagResourceOutput, RusotoError<UntagResourceError>>;
}
#[derive(Clone)]
pub struct MediaStoreClient {
client: Client,
region: region::Region,
}
impl MediaStoreClient {
pub fn new(region: region::Region) -> MediaStoreClient {
MediaStoreClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> MediaStoreClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
MediaStoreClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> MediaStoreClient {
MediaStoreClient { client, region }
}
}
#[async_trait]
impl MediaStore for MediaStoreClient {
async fn create_container(
&self,
input: CreateContainerInput,
) -> Result<CreateContainerOutput, RusotoError<CreateContainerError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.CreateContainer");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateContainerOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateContainerError::from_response(response))
}
}
async fn delete_container(
&self,
input: DeleteContainerInput,
) -> Result<DeleteContainerOutput, RusotoError<DeleteContainerError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.DeleteContainer");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteContainerOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteContainerError::from_response(response))
}
}
async fn delete_container_policy(
&self,
input: DeleteContainerPolicyInput,
) -> Result<DeleteContainerPolicyOutput, RusotoError<DeleteContainerPolicyError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.DeleteContainerPolicy");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteContainerPolicyOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteContainerPolicyError::from_response(response))
}
}
async fn delete_cors_policy(
&self,
input: DeleteCorsPolicyInput,
) -> Result<DeleteCorsPolicyOutput, RusotoError<DeleteCorsPolicyError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.DeleteCorsPolicy");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteCorsPolicyOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteCorsPolicyError::from_response(response))
}
}
async fn delete_lifecycle_policy(
&self,
input: DeleteLifecyclePolicyInput,
) -> Result<DeleteLifecyclePolicyOutput, RusotoError<DeleteLifecyclePolicyError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.DeleteLifecyclePolicy");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteLifecyclePolicyOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteLifecyclePolicyError::from_response(response))
}
}
async fn describe_container(
&self,
input: DescribeContainerInput,
) -> Result<DescribeContainerOutput, RusotoError<DescribeContainerError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.DescribeContainer");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeContainerOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeContainerError::from_response(response))
}
}
async fn get_container_policy(
&self,
input: GetContainerPolicyInput,
) -> Result<GetContainerPolicyOutput, RusotoError<GetContainerPolicyError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.GetContainerPolicy");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetContainerPolicyOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetContainerPolicyError::from_response(response))
}
}
async fn get_cors_policy(
&self,
input: GetCorsPolicyInput,
) -> Result<GetCorsPolicyOutput, RusotoError<GetCorsPolicyError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.GetCorsPolicy");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetCorsPolicyOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetCorsPolicyError::from_response(response))
}
}
async fn get_lifecycle_policy(
&self,
input: GetLifecyclePolicyInput,
) -> Result<GetLifecyclePolicyOutput, RusotoError<GetLifecyclePolicyError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.GetLifecyclePolicy");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetLifecyclePolicyOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetLifecyclePolicyError::from_response(response))
}
}
async fn list_containers(
&self,
input: ListContainersInput,
) -> Result<ListContainersOutput, RusotoError<ListContainersError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.ListContainers");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListContainersOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListContainersError::from_response(response))
}
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceInput,
) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.ListTagsForResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
async fn put_container_policy(
&self,
input: PutContainerPolicyInput,
) -> Result<PutContainerPolicyOutput, RusotoError<PutContainerPolicyError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.PutContainerPolicy");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutContainerPolicyOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(PutContainerPolicyError::from_response(response))
}
}
async fn put_cors_policy(
&self,
input: PutCorsPolicyInput,
) -> Result<PutCorsPolicyOutput, RusotoError<PutCorsPolicyError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.PutCorsPolicy");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<PutCorsPolicyOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(PutCorsPolicyError::from_response(response))
}
}
async fn put_lifecycle_policy(
&self,
input: PutLifecyclePolicyInput,
) -> Result<PutLifecyclePolicyOutput, RusotoError<PutLifecyclePolicyError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.PutLifecyclePolicy");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutLifecyclePolicyOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(PutLifecyclePolicyError::from_response(response))
}
}
async fn start_access_logging(
&self,
input: StartAccessLoggingInput,
) -> Result<StartAccessLoggingOutput, RusotoError<StartAccessLoggingError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.StartAccessLogging");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartAccessLoggingOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(StartAccessLoggingError::from_response(response))
}
}
async fn stop_access_logging(
&self,
input: StopAccessLoggingInput,
) -> Result<StopAccessLoggingOutput, RusotoError<StopAccessLoggingError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.StopAccessLogging");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StopAccessLoggingOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(StopAccessLoggingError::from_response(response))
}
}
async fn tag_resource(
&self,
input: TagResourceInput,
) -> Result<TagResourceOutput, RusotoError<TagResourceError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
async fn untag_resource(
&self,
input: UntagResourceInput,
) -> Result<UntagResourceOutput, RusotoError<UntagResourceError>> {
let mut request = SignedRequest::new("POST", "mediastore", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MediaStore_20170901.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
}