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::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CdnConfiguration {
#[serde(rename = "AdSegmentUrlPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ad_segment_url_prefix: Option<String>,
#[serde(rename = "ContentSegmentUrlPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_segment_url_prefix: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DashConfiguration {
#[serde(rename = "ManifestEndpointPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_endpoint_prefix: Option<String>,
#[serde(rename = "MpdLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mpd_location: Option<String>,
#[serde(rename = "OriginManifestType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub origin_manifest_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DashConfigurationForPut {
#[serde(rename = "MpdLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mpd_location: Option<String>,
#[serde(rename = "OriginManifestType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub origin_manifest_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePlaybackConfigurationRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeletePlaybackConfigurationResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetPlaybackConfigurationRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetPlaybackConfigurationResponse {
#[serde(rename = "AdDecisionServerUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ad_decision_server_url: Option<String>,
#[serde(rename = "CdnConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdn_configuration: Option<CdnConfiguration>,
#[serde(rename = "DashConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dash_configuration: Option<DashConfiguration>,
#[serde(rename = "HlsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hls_configuration: Option<HlsConfiguration>,
#[serde(rename = "LivePreRollConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub live_pre_roll_configuration: Option<LivePreRollConfiguration>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "PlaybackConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub playback_configuration_arn: Option<String>,
#[serde(rename = "PlaybackEndpointPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub playback_endpoint_prefix: Option<String>,
#[serde(rename = "SessionInitializationEndpointPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session_initialization_endpoint_prefix: Option<String>,
#[serde(rename = "SlateAdUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub slate_ad_url: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TranscodeProfileName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcode_profile_name: Option<String>,
#[serde(rename = "VideoContentSourceUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_content_source_url: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HlsConfiguration {
#[serde(rename = "ManifestEndpointPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manifest_endpoint_prefix: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPlaybackConfigurationsRequest {
#[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 ListPlaybackConfigurationsResponse {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<PlaybackConfiguration>>,
#[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 ListTagsForResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LivePreRollConfiguration {
#[serde(rename = "AdDecisionServerUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ad_decision_server_url: Option<String>,
#[serde(rename = "MaxDurationSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_duration_seconds: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PlaybackConfiguration {
#[serde(rename = "AdDecisionServerUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ad_decision_server_url: Option<String>,
#[serde(rename = "CdnConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdn_configuration: Option<CdnConfiguration>,
#[serde(rename = "DashConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dash_configuration: Option<DashConfiguration>,
#[serde(rename = "HlsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hls_configuration: Option<HlsConfiguration>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "PlaybackConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub playback_configuration_arn: Option<String>,
#[serde(rename = "PlaybackEndpointPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub playback_endpoint_prefix: Option<String>,
#[serde(rename = "SessionInitializationEndpointPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session_initialization_endpoint_prefix: Option<String>,
#[serde(rename = "SlateAdUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub slate_ad_url: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TranscodeProfileName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcode_profile_name: Option<String>,
#[serde(rename = "VideoContentSourceUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_content_source_url: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutPlaybackConfigurationRequest {
#[serde(rename = "AdDecisionServerUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ad_decision_server_url: Option<String>,
#[serde(rename = "CdnConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdn_configuration: Option<CdnConfiguration>,
#[serde(rename = "DashConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dash_configuration: Option<DashConfigurationForPut>,
#[serde(rename = "LivePreRollConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub live_pre_roll_configuration: Option<LivePreRollConfiguration>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SlateAdUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub slate_ad_url: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TranscodeProfileName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcode_profile_name: Option<String>,
#[serde(rename = "VideoContentSourceUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_content_source_url: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutPlaybackConfigurationResponse {
#[serde(rename = "AdDecisionServerUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ad_decision_server_url: Option<String>,
#[serde(rename = "CdnConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cdn_configuration: Option<CdnConfiguration>,
#[serde(rename = "DashConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dash_configuration: Option<DashConfiguration>,
#[serde(rename = "HlsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hls_configuration: Option<HlsConfiguration>,
#[serde(rename = "LivePreRollConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub live_pre_roll_configuration: Option<LivePreRollConfiguration>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "PlaybackConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub playback_configuration_arn: Option<String>,
#[serde(rename = "PlaybackEndpointPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub playback_endpoint_prefix: Option<String>,
#[serde(rename = "SessionInitializationEndpointPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session_initialization_endpoint_prefix: Option<String>,
#[serde(rename = "SlateAdUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub slate_ad_url: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TranscodeProfileName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transcode_profile_name: Option<String>,
#[serde(rename = "VideoContentSourceUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub video_content_source_url: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Debug, PartialEq)]
pub enum DeletePlaybackConfigurationError {}
impl DeletePlaybackConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeletePlaybackConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeletePlaybackConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DeletePlaybackConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum GetPlaybackConfigurationError {}
impl GetPlaybackConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetPlaybackConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetPlaybackConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for GetPlaybackConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum ListPlaybackConfigurationsError {}
impl ListPlaybackConfigurationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListPlaybackConfigurationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPlaybackConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListPlaybackConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
BadRequest(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListTagsForResourceError::BadRequest(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::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum PutPlaybackConfigurationError {}
impl PutPlaybackConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutPlaybackConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutPlaybackConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for PutPlaybackConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
BadRequest(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(TagResourceError::BadRequest(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::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
BadRequest(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UntagResourceError::BadRequest(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::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[async_trait]
pub trait MediaTailor {
async fn delete_playback_configuration(
&self,
input: DeletePlaybackConfigurationRequest,
) -> Result<DeletePlaybackConfigurationResponse, RusotoError<DeletePlaybackConfigurationError>>;
async fn get_playback_configuration(
&self,
input: GetPlaybackConfigurationRequest,
) -> Result<GetPlaybackConfigurationResponse, RusotoError<GetPlaybackConfigurationError>>;
async fn list_playback_configurations(
&self,
input: ListPlaybackConfigurationsRequest,
) -> Result<ListPlaybackConfigurationsResponse, RusotoError<ListPlaybackConfigurationsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn put_playback_configuration(
&self,
input: PutPlaybackConfigurationRequest,
) -> Result<PutPlaybackConfigurationResponse, RusotoError<PutPlaybackConfigurationError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>>;
}
#[derive(Clone)]
pub struct MediaTailorClient {
client: Client,
region: region::Region,
}
impl MediaTailorClient {
pub fn new(region: region::Region) -> MediaTailorClient {
MediaTailorClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> MediaTailorClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
MediaTailorClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> MediaTailorClient {
MediaTailorClient { client, region }
}
}
#[async_trait]
impl MediaTailor for MediaTailorClient {
async fn delete_playback_configuration(
&self,
input: DeletePlaybackConfigurationRequest,
) -> Result<DeletePlaybackConfigurationResponse, RusotoError<DeletePlaybackConfigurationError>>
{
let request_uri = format!("/playbackConfiguration/{name}", name = input.name);
let mut request = SignedRequest::new("DELETE", "mediatailor", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("api.mediatailor".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeletePlaybackConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeletePlaybackConfigurationError::from_response(response))
}
}
async fn get_playback_configuration(
&self,
input: GetPlaybackConfigurationRequest,
) -> Result<GetPlaybackConfigurationResponse, RusotoError<GetPlaybackConfigurationError>> {
let request_uri = format!("/playbackConfiguration/{name}", name = input.name);
let mut request = SignedRequest::new("GET", "mediatailor", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("api.mediatailor".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetPlaybackConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetPlaybackConfigurationError::from_response(response))
}
}
async fn list_playback_configurations(
&self,
input: ListPlaybackConfigurationsRequest,
) -> Result<ListPlaybackConfigurationsResponse, RusotoError<ListPlaybackConfigurationsError>>
{
let request_uri = "/playbackConfigurations";
let mut request = SignedRequest::new("GET", "mediatailor", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("api.mediatailor".to_string());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListPlaybackConfigurationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListPlaybackConfigurationsError::from_response(response))
}
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "mediatailor", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("api.mediatailor".to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
async fn put_playback_configuration(
&self,
input: PutPlaybackConfigurationRequest,
) -> Result<PutPlaybackConfigurationResponse, RusotoError<PutPlaybackConfigurationError>> {
let request_uri = "/playbackConfiguration";
let mut request = SignedRequest::new("PUT", "mediatailor", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("api.mediatailor".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutPlaybackConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutPlaybackConfigurationError::from_response(response))
}
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "mediatailor", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("api.mediatailor".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "mediatailor", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("api.mediatailor".to_string());
let mut params = Params::new();
for item in input.tag_keys.iter() {
params.put("tagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
}