use std::error::Error;
use std::fmt;
use std::io;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoFuture};
use rusoto_core::credential::{CredentialsError, ProvideAwsCredentials};
use rusoto_core::request::HttpDispatchError;
use rusoto_core::signature::SignedRequest;
use serde_json;
use serde_json::from_slice;
use serde_json::Value as SerdeJsonValue;
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateStreamInput {
#[serde(rename = "DataRetentionInHours")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_retention_in_hours: Option<i64>,
#[serde(rename = "DeviceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_name: Option<String>,
#[serde(rename = "KmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "MediaType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_type: Option<String>,
#[serde(rename = "StreamName")]
pub stream_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateStreamOutput {
#[serde(rename = "StreamARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteStreamInput {
#[serde(rename = "CurrentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_version: Option<String>,
#[serde(rename = "StreamARN")]
pub stream_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteStreamOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeStreamInput {
#[serde(rename = "StreamARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_arn: Option<String>,
#[serde(rename = "StreamName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeStreamOutput {
#[serde(rename = "StreamInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_info: Option<StreamInfo>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetDataEndpointInput {
#[serde(rename = "APIName")]
pub api_name: String,
#[serde(rename = "StreamARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_arn: Option<String>,
#[serde(rename = "StreamName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetDataEndpointOutput {
#[serde(rename = "DataEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_endpoint: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListStreamsInput {
#[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 = "StreamNameCondition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_name_condition: Option<StreamNameCondition>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListStreamsOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "StreamInfoList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_info_list: Option<Vec<StreamInfo>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListTagsForStreamInput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "StreamARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_arn: Option<String>,
#[serde(rename = "StreamName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListTagsForStreamOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StreamInfo {
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "DataRetentionInHours")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_retention_in_hours: Option<i64>,
#[serde(rename = "DeviceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_name: Option<String>,
#[serde(rename = "KmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "MediaType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_type: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StreamARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_arn: Option<String>,
#[serde(rename = "StreamName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_name: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StreamNameCondition {
#[serde(rename = "ComparisonOperator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comparison_operator: Option<String>,
#[serde(rename = "ComparisonValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comparison_value: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct TagStreamInput {
#[serde(rename = "StreamARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_arn: Option<String>,
#[serde(rename = "StreamName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_name: Option<String>,
#[serde(rename = "Tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct TagStreamOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UntagStreamInput {
#[serde(rename = "StreamARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_arn: Option<String>,
#[serde(rename = "StreamName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_name: Option<String>,
#[serde(rename = "TagKeyList")]
pub tag_key_list: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UntagStreamOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateDataRetentionInput {
#[serde(rename = "CurrentVersion")]
pub current_version: String,
#[serde(rename = "DataRetentionChangeInHours")]
pub data_retention_change_in_hours: i64,
#[serde(rename = "Operation")]
pub operation: String,
#[serde(rename = "StreamARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_arn: Option<String>,
#[serde(rename = "StreamName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateDataRetentionOutput {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateStreamInput {
#[serde(rename = "CurrentVersion")]
pub current_version: String,
#[serde(rename = "DeviceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_name: Option<String>,
#[serde(rename = "MediaType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_type: Option<String>,
#[serde(rename = "StreamARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_arn: Option<String>,
#[serde(rename = "StreamName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateStreamOutput {}
#[derive(Debug, PartialEq)]
pub enum CreateStreamError {
AccountStreamLimitExceeded(String),
ClientLimitExceeded(String),
DeviceStreamLimitExceeded(String),
InvalidArgument(String),
InvalidDevice(String),
ResourceInUse(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateStreamError {
pub fn from_response(res: BufferedHttpResponse) -> CreateStreamError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"AccountStreamLimitExceededException" => {
return CreateStreamError::AccountStreamLimitExceeded(String::from(
error_message,
))
}
"ClientLimitExceededException" => {
return CreateStreamError::ClientLimitExceeded(String::from(error_message))
}
"DeviceStreamLimitExceededException" => {
return CreateStreamError::DeviceStreamLimitExceeded(String::from(error_message))
}
"InvalidArgumentException" => {
return CreateStreamError::InvalidArgument(String::from(error_message))
}
"InvalidDeviceException" => {
return CreateStreamError::InvalidDevice(String::from(error_message))
}
"ResourceInUseException" => {
return CreateStreamError::ResourceInUse(String::from(error_message))
}
"ValidationException" => {
return CreateStreamError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateStreamError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateStreamError {
fn from(err: serde_json::error::Error) -> CreateStreamError {
CreateStreamError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateStreamError {
fn from(err: CredentialsError) -> CreateStreamError {
CreateStreamError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateStreamError {
fn from(err: HttpDispatchError) -> CreateStreamError {
CreateStreamError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateStreamError {
fn from(err: io::Error) -> CreateStreamError {
CreateStreamError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateStreamError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateStreamError {
fn description(&self) -> &str {
match *self {
CreateStreamError::AccountStreamLimitExceeded(ref cause) => cause,
CreateStreamError::ClientLimitExceeded(ref cause) => cause,
CreateStreamError::DeviceStreamLimitExceeded(ref cause) => cause,
CreateStreamError::InvalidArgument(ref cause) => cause,
CreateStreamError::InvalidDevice(ref cause) => cause,
CreateStreamError::ResourceInUse(ref cause) => cause,
CreateStreamError::Validation(ref cause) => cause,
CreateStreamError::Credentials(ref err) => err.description(),
CreateStreamError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateStreamError::ParseError(ref cause) => cause,
CreateStreamError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteStreamError {
ClientLimitExceeded(String),
InvalidArgument(String),
NotAuthorized(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteStreamError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteStreamError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ClientLimitExceededException" => {
return DeleteStreamError::ClientLimitExceeded(String::from(error_message))
}
"InvalidArgumentException" => {
return DeleteStreamError::InvalidArgument(String::from(error_message))
}
"NotAuthorizedException" => {
return DeleteStreamError::NotAuthorized(String::from(error_message))
}
"ResourceNotFoundException" => {
return DeleteStreamError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DeleteStreamError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteStreamError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteStreamError {
fn from(err: serde_json::error::Error) -> DeleteStreamError {
DeleteStreamError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteStreamError {
fn from(err: CredentialsError) -> DeleteStreamError {
DeleteStreamError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteStreamError {
fn from(err: HttpDispatchError) -> DeleteStreamError {
DeleteStreamError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteStreamError {
fn from(err: io::Error) -> DeleteStreamError {
DeleteStreamError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteStreamError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteStreamError {
fn description(&self) -> &str {
match *self {
DeleteStreamError::ClientLimitExceeded(ref cause) => cause,
DeleteStreamError::InvalidArgument(ref cause) => cause,
DeleteStreamError::NotAuthorized(ref cause) => cause,
DeleteStreamError::ResourceNotFound(ref cause) => cause,
DeleteStreamError::Validation(ref cause) => cause,
DeleteStreamError::Credentials(ref err) => err.description(),
DeleteStreamError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteStreamError::ParseError(ref cause) => cause,
DeleteStreamError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeStreamError {
ClientLimitExceeded(String),
InvalidArgument(String),
NotAuthorized(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeStreamError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeStreamError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ClientLimitExceededException" => {
return DescribeStreamError::ClientLimitExceeded(String::from(error_message))
}
"InvalidArgumentException" => {
return DescribeStreamError::InvalidArgument(String::from(error_message))
}
"NotAuthorizedException" => {
return DescribeStreamError::NotAuthorized(String::from(error_message))
}
"ResourceNotFoundException" => {
return DescribeStreamError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DescribeStreamError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeStreamError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeStreamError {
fn from(err: serde_json::error::Error) -> DescribeStreamError {
DescribeStreamError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeStreamError {
fn from(err: CredentialsError) -> DescribeStreamError {
DescribeStreamError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeStreamError {
fn from(err: HttpDispatchError) -> DescribeStreamError {
DescribeStreamError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeStreamError {
fn from(err: io::Error) -> DescribeStreamError {
DescribeStreamError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeStreamError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeStreamError {
fn description(&self) -> &str {
match *self {
DescribeStreamError::ClientLimitExceeded(ref cause) => cause,
DescribeStreamError::InvalidArgument(ref cause) => cause,
DescribeStreamError::NotAuthorized(ref cause) => cause,
DescribeStreamError::ResourceNotFound(ref cause) => cause,
DescribeStreamError::Validation(ref cause) => cause,
DescribeStreamError::Credentials(ref err) => err.description(),
DescribeStreamError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeStreamError::ParseError(ref cause) => cause,
DescribeStreamError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetDataEndpointError {
ClientLimitExceeded(String),
InvalidArgument(String),
NotAuthorized(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetDataEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> GetDataEndpointError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ClientLimitExceededException" => {
return GetDataEndpointError::ClientLimitExceeded(String::from(error_message))
}
"InvalidArgumentException" => {
return GetDataEndpointError::InvalidArgument(String::from(error_message))
}
"NotAuthorizedException" => {
return GetDataEndpointError::NotAuthorized(String::from(error_message))
}
"ResourceNotFoundException" => {
return GetDataEndpointError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return GetDataEndpointError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetDataEndpointError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetDataEndpointError {
fn from(err: serde_json::error::Error) -> GetDataEndpointError {
GetDataEndpointError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetDataEndpointError {
fn from(err: CredentialsError) -> GetDataEndpointError {
GetDataEndpointError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetDataEndpointError {
fn from(err: HttpDispatchError) -> GetDataEndpointError {
GetDataEndpointError::HttpDispatch(err)
}
}
impl From<io::Error> for GetDataEndpointError {
fn from(err: io::Error) -> GetDataEndpointError {
GetDataEndpointError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetDataEndpointError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetDataEndpointError {
fn description(&self) -> &str {
match *self {
GetDataEndpointError::ClientLimitExceeded(ref cause) => cause,
GetDataEndpointError::InvalidArgument(ref cause) => cause,
GetDataEndpointError::NotAuthorized(ref cause) => cause,
GetDataEndpointError::ResourceNotFound(ref cause) => cause,
GetDataEndpointError::Validation(ref cause) => cause,
GetDataEndpointError::Credentials(ref err) => err.description(),
GetDataEndpointError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetDataEndpointError::ParseError(ref cause) => cause,
GetDataEndpointError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListStreamsError {
ClientLimitExceeded(String),
InvalidArgument(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListStreamsError {
pub fn from_response(res: BufferedHttpResponse) -> ListStreamsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ClientLimitExceededException" => {
return ListStreamsError::ClientLimitExceeded(String::from(error_message))
}
"InvalidArgumentException" => {
return ListStreamsError::InvalidArgument(String::from(error_message))
}
"ValidationException" => {
return ListStreamsError::Validation(error_message.to_string())
}
_ => {}
}
}
return ListStreamsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListStreamsError {
fn from(err: serde_json::error::Error) -> ListStreamsError {
ListStreamsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListStreamsError {
fn from(err: CredentialsError) -> ListStreamsError {
ListStreamsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListStreamsError {
fn from(err: HttpDispatchError) -> ListStreamsError {
ListStreamsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListStreamsError {
fn from(err: io::Error) -> ListStreamsError {
ListStreamsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListStreamsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListStreamsError {
fn description(&self) -> &str {
match *self {
ListStreamsError::ClientLimitExceeded(ref cause) => cause,
ListStreamsError::InvalidArgument(ref cause) => cause,
ListStreamsError::Validation(ref cause) => cause,
ListStreamsError::Credentials(ref err) => err.description(),
ListStreamsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListStreamsError::ParseError(ref cause) => cause,
ListStreamsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTagsForStreamError {
ClientLimitExceeded(String),
InvalidArgument(String),
InvalidResourceFormat(String),
NotAuthorized(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTagsForStreamError {
pub fn from_response(res: BufferedHttpResponse) -> ListTagsForStreamError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ClientLimitExceededException" => {
return ListTagsForStreamError::ClientLimitExceeded(String::from(error_message))
}
"InvalidArgumentException" => {
return ListTagsForStreamError::InvalidArgument(String::from(error_message))
}
"InvalidResourceFormatException" => {
return ListTagsForStreamError::InvalidResourceFormat(String::from(
error_message,
))
}
"NotAuthorizedException" => {
return ListTagsForStreamError::NotAuthorized(String::from(error_message))
}
"ResourceNotFoundException" => {
return ListTagsForStreamError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return ListTagsForStreamError::Validation(error_message.to_string())
}
_ => {}
}
}
return ListTagsForStreamError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListTagsForStreamError {
fn from(err: serde_json::error::Error) -> ListTagsForStreamError {
ListTagsForStreamError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListTagsForStreamError {
fn from(err: CredentialsError) -> ListTagsForStreamError {
ListTagsForStreamError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTagsForStreamError {
fn from(err: HttpDispatchError) -> ListTagsForStreamError {
ListTagsForStreamError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTagsForStreamError {
fn from(err: io::Error) -> ListTagsForStreamError {
ListTagsForStreamError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTagsForStreamError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTagsForStreamError {
fn description(&self) -> &str {
match *self {
ListTagsForStreamError::ClientLimitExceeded(ref cause) => cause,
ListTagsForStreamError::InvalidArgument(ref cause) => cause,
ListTagsForStreamError::InvalidResourceFormat(ref cause) => cause,
ListTagsForStreamError::NotAuthorized(ref cause) => cause,
ListTagsForStreamError::ResourceNotFound(ref cause) => cause,
ListTagsForStreamError::Validation(ref cause) => cause,
ListTagsForStreamError::Credentials(ref err) => err.description(),
ListTagsForStreamError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTagsForStreamError::ParseError(ref cause) => cause,
ListTagsForStreamError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum TagStreamError {
ClientLimitExceeded(String),
InvalidArgument(String),
InvalidResourceFormat(String),
NotAuthorized(String),
ResourceNotFound(String),
TagsPerResourceExceededLimit(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl TagStreamError {
pub fn from_response(res: BufferedHttpResponse) -> TagStreamError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ClientLimitExceededException" => {
return TagStreamError::ClientLimitExceeded(String::from(error_message))
}
"InvalidArgumentException" => {
return TagStreamError::InvalidArgument(String::from(error_message))
}
"InvalidResourceFormatException" => {
return TagStreamError::InvalidResourceFormat(String::from(error_message))
}
"NotAuthorizedException" => {
return TagStreamError::NotAuthorized(String::from(error_message))
}
"ResourceNotFoundException" => {
return TagStreamError::ResourceNotFound(String::from(error_message))
}
"TagsPerResourceExceededLimitException" => {
return TagStreamError::TagsPerResourceExceededLimit(String::from(error_message))
}
"ValidationException" => {
return TagStreamError::Validation(error_message.to_string())
}
_ => {}
}
}
return TagStreamError::Unknown(res);
}
}
impl From<serde_json::error::Error> for TagStreamError {
fn from(err: serde_json::error::Error) -> TagStreamError {
TagStreamError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for TagStreamError {
fn from(err: CredentialsError) -> TagStreamError {
TagStreamError::Credentials(err)
}
}
impl From<HttpDispatchError> for TagStreamError {
fn from(err: HttpDispatchError) -> TagStreamError {
TagStreamError::HttpDispatch(err)
}
}
impl From<io::Error> for TagStreamError {
fn from(err: io::Error) -> TagStreamError {
TagStreamError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for TagStreamError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for TagStreamError {
fn description(&self) -> &str {
match *self {
TagStreamError::ClientLimitExceeded(ref cause) => cause,
TagStreamError::InvalidArgument(ref cause) => cause,
TagStreamError::InvalidResourceFormat(ref cause) => cause,
TagStreamError::NotAuthorized(ref cause) => cause,
TagStreamError::ResourceNotFound(ref cause) => cause,
TagStreamError::TagsPerResourceExceededLimit(ref cause) => cause,
TagStreamError::Validation(ref cause) => cause,
TagStreamError::Credentials(ref err) => err.description(),
TagStreamError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
TagStreamError::ParseError(ref cause) => cause,
TagStreamError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UntagStreamError {
ClientLimitExceeded(String),
InvalidArgument(String),
InvalidResourceFormat(String),
NotAuthorized(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UntagStreamError {
pub fn from_response(res: BufferedHttpResponse) -> UntagStreamError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ClientLimitExceededException" => {
return UntagStreamError::ClientLimitExceeded(String::from(error_message))
}
"InvalidArgumentException" => {
return UntagStreamError::InvalidArgument(String::from(error_message))
}
"InvalidResourceFormatException" => {
return UntagStreamError::InvalidResourceFormat(String::from(error_message))
}
"NotAuthorizedException" => {
return UntagStreamError::NotAuthorized(String::from(error_message))
}
"ResourceNotFoundException" => {
return UntagStreamError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return UntagStreamError::Validation(error_message.to_string())
}
_ => {}
}
}
return UntagStreamError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UntagStreamError {
fn from(err: serde_json::error::Error) -> UntagStreamError {
UntagStreamError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UntagStreamError {
fn from(err: CredentialsError) -> UntagStreamError {
UntagStreamError::Credentials(err)
}
}
impl From<HttpDispatchError> for UntagStreamError {
fn from(err: HttpDispatchError) -> UntagStreamError {
UntagStreamError::HttpDispatch(err)
}
}
impl From<io::Error> for UntagStreamError {
fn from(err: io::Error) -> UntagStreamError {
UntagStreamError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UntagStreamError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UntagStreamError {
fn description(&self) -> &str {
match *self {
UntagStreamError::ClientLimitExceeded(ref cause) => cause,
UntagStreamError::InvalidArgument(ref cause) => cause,
UntagStreamError::InvalidResourceFormat(ref cause) => cause,
UntagStreamError::NotAuthorized(ref cause) => cause,
UntagStreamError::ResourceNotFound(ref cause) => cause,
UntagStreamError::Validation(ref cause) => cause,
UntagStreamError::Credentials(ref err) => err.description(),
UntagStreamError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UntagStreamError::ParseError(ref cause) => cause,
UntagStreamError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateDataRetentionError {
ClientLimitExceeded(String),
InvalidArgument(String),
NotAuthorized(String),
ResourceInUse(String),
ResourceNotFound(String),
VersionMismatch(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateDataRetentionError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateDataRetentionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ClientLimitExceededException" => {
return UpdateDataRetentionError::ClientLimitExceeded(String::from(
error_message,
))
}
"InvalidArgumentException" => {
return UpdateDataRetentionError::InvalidArgument(String::from(error_message))
}
"NotAuthorizedException" => {
return UpdateDataRetentionError::NotAuthorized(String::from(error_message))
}
"ResourceInUseException" => {
return UpdateDataRetentionError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return UpdateDataRetentionError::ResourceNotFound(String::from(error_message))
}
"VersionMismatchException" => {
return UpdateDataRetentionError::VersionMismatch(String::from(error_message))
}
"ValidationException" => {
return UpdateDataRetentionError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateDataRetentionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateDataRetentionError {
fn from(err: serde_json::error::Error) -> UpdateDataRetentionError {
UpdateDataRetentionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateDataRetentionError {
fn from(err: CredentialsError) -> UpdateDataRetentionError {
UpdateDataRetentionError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateDataRetentionError {
fn from(err: HttpDispatchError) -> UpdateDataRetentionError {
UpdateDataRetentionError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateDataRetentionError {
fn from(err: io::Error) -> UpdateDataRetentionError {
UpdateDataRetentionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateDataRetentionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateDataRetentionError {
fn description(&self) -> &str {
match *self {
UpdateDataRetentionError::ClientLimitExceeded(ref cause) => cause,
UpdateDataRetentionError::InvalidArgument(ref cause) => cause,
UpdateDataRetentionError::NotAuthorized(ref cause) => cause,
UpdateDataRetentionError::ResourceInUse(ref cause) => cause,
UpdateDataRetentionError::ResourceNotFound(ref cause) => cause,
UpdateDataRetentionError::VersionMismatch(ref cause) => cause,
UpdateDataRetentionError::Validation(ref cause) => cause,
UpdateDataRetentionError::Credentials(ref err) => err.description(),
UpdateDataRetentionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateDataRetentionError::ParseError(ref cause) => cause,
UpdateDataRetentionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateStreamError {
ClientLimitExceeded(String),
InvalidArgument(String),
NotAuthorized(String),
ResourceInUse(String),
ResourceNotFound(String),
VersionMismatch(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateStreamError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateStreamError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ClientLimitExceededException" => {
return UpdateStreamError::ClientLimitExceeded(String::from(error_message))
}
"InvalidArgumentException" => {
return UpdateStreamError::InvalidArgument(String::from(error_message))
}
"NotAuthorizedException" => {
return UpdateStreamError::NotAuthorized(String::from(error_message))
}
"ResourceInUseException" => {
return UpdateStreamError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return UpdateStreamError::ResourceNotFound(String::from(error_message))
}
"VersionMismatchException" => {
return UpdateStreamError::VersionMismatch(String::from(error_message))
}
"ValidationException" => {
return UpdateStreamError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateStreamError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateStreamError {
fn from(err: serde_json::error::Error) -> UpdateStreamError {
UpdateStreamError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateStreamError {
fn from(err: CredentialsError) -> UpdateStreamError {
UpdateStreamError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateStreamError {
fn from(err: HttpDispatchError) -> UpdateStreamError {
UpdateStreamError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateStreamError {
fn from(err: io::Error) -> UpdateStreamError {
UpdateStreamError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateStreamError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateStreamError {
fn description(&self) -> &str {
match *self {
UpdateStreamError::ClientLimitExceeded(ref cause) => cause,
UpdateStreamError::InvalidArgument(ref cause) => cause,
UpdateStreamError::NotAuthorized(ref cause) => cause,
UpdateStreamError::ResourceInUse(ref cause) => cause,
UpdateStreamError::ResourceNotFound(ref cause) => cause,
UpdateStreamError::VersionMismatch(ref cause) => cause,
UpdateStreamError::Validation(ref cause) => cause,
UpdateStreamError::Credentials(ref err) => err.description(),
UpdateStreamError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateStreamError::ParseError(ref cause) => cause,
UpdateStreamError::Unknown(_) => "unknown error",
}
}
}
pub trait KinesisVideo {
fn create_stream(
&self,
input: CreateStreamInput,
) -> RusotoFuture<CreateStreamOutput, CreateStreamError>;
fn delete_stream(
&self,
input: DeleteStreamInput,
) -> RusotoFuture<DeleteStreamOutput, DeleteStreamError>;
fn describe_stream(
&self,
input: DescribeStreamInput,
) -> RusotoFuture<DescribeStreamOutput, DescribeStreamError>;
fn get_data_endpoint(
&self,
input: GetDataEndpointInput,
) -> RusotoFuture<GetDataEndpointOutput, GetDataEndpointError>;
fn list_streams(
&self,
input: ListStreamsInput,
) -> RusotoFuture<ListStreamsOutput, ListStreamsError>;
fn list_tags_for_stream(
&self,
input: ListTagsForStreamInput,
) -> RusotoFuture<ListTagsForStreamOutput, ListTagsForStreamError>;
fn tag_stream(&self, input: TagStreamInput) -> RusotoFuture<TagStreamOutput, TagStreamError>;
fn untag_stream(
&self,
input: UntagStreamInput,
) -> RusotoFuture<UntagStreamOutput, UntagStreamError>;
fn update_data_retention(
&self,
input: UpdateDataRetentionInput,
) -> RusotoFuture<UpdateDataRetentionOutput, UpdateDataRetentionError>;
fn update_stream(
&self,
input: UpdateStreamInput,
) -> RusotoFuture<UpdateStreamOutput, UpdateStreamError>;
}
pub struct KinesisVideoClient {
client: Client,
region: region::Region,
}
impl KinesisVideoClient {
pub fn new(region: region::Region) -> KinesisVideoClient {
KinesisVideoClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> KinesisVideoClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
KinesisVideoClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl KinesisVideo for KinesisVideoClient {
fn create_stream(
&self,
input: CreateStreamInput,
) -> RusotoFuture<CreateStreamOutput, CreateStreamError> {
let request_uri = "/createStream";
let mut request = SignedRequest::new("POST", "kinesisvideo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
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 == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<CreateStreamOutput>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateStreamError::from_response(response))),
)
}
})
}
fn delete_stream(
&self,
input: DeleteStreamInput,
) -> RusotoFuture<DeleteStreamOutput, DeleteStreamError> {
let request_uri = "/deleteStream";
let mut request = SignedRequest::new("POST", "kinesisvideo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
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 == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<DeleteStreamOutput>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteStreamError::from_response(response))),
)
}
})
}
fn describe_stream(
&self,
input: DescribeStreamInput,
) -> RusotoFuture<DescribeStreamOutput, DescribeStreamError> {
let request_uri = "/describeStream";
let mut request = SignedRequest::new("POST", "kinesisvideo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
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 == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<DescribeStreamOutput>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeStreamError::from_response(response))),
)
}
})
}
fn get_data_endpoint(
&self,
input: GetDataEndpointInput,
) -> RusotoFuture<GetDataEndpointOutput, GetDataEndpointError> {
let request_uri = "/getDataEndpoint";
let mut request = SignedRequest::new("POST", "kinesisvideo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
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 == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<GetDataEndpointOutput>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetDataEndpointError::from_response(response))),
)
}
})
}
fn list_streams(
&self,
input: ListStreamsInput,
) -> RusotoFuture<ListStreamsOutput, ListStreamsError> {
let request_uri = "/listStreams";
let mut request = SignedRequest::new("POST", "kinesisvideo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
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 == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<ListStreamsOutput>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListStreamsError::from_response(response))),
)
}
})
}
fn list_tags_for_stream(
&self,
input: ListTagsForStreamInput,
) -> RusotoFuture<ListTagsForStreamOutput, ListTagsForStreamError> {
let request_uri = "/listTagsForStream";
let mut request = SignedRequest::new("POST", "kinesisvideo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
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 == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<ListTagsForStreamOutput>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListTagsForStreamError::from_response(response))),
)
}
})
}
fn tag_stream(&self, input: TagStreamInput) -> RusotoFuture<TagStreamOutput, TagStreamError> {
let request_uri = "/tagStream";
let mut request = SignedRequest::new("POST", "kinesisvideo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
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 == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<TagStreamOutput>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(TagStreamError::from_response(response))),
)
}
})
}
fn untag_stream(
&self,
input: UntagStreamInput,
) -> RusotoFuture<UntagStreamOutput, UntagStreamError> {
let request_uri = "/untagStream";
let mut request = SignedRequest::new("POST", "kinesisvideo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
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 == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<UntagStreamOutput>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UntagStreamError::from_response(response))),
)
}
})
}
fn update_data_retention(
&self,
input: UpdateDataRetentionInput,
) -> RusotoFuture<UpdateDataRetentionOutput, UpdateDataRetentionError> {
let request_uri = "/updateDataRetention";
let mut request = SignedRequest::new("POST", "kinesisvideo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
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 == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<UpdateDataRetentionOutput>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(UpdateDataRetentionError::from_response(response))
}),
)
}
})
}
fn update_stream(
&self,
input: UpdateStreamInput,
) -> RusotoFuture<UpdateStreamOutput, UpdateStreamError> {
let request_uri = "/updateStream";
let mut request = SignedRequest::new("POST", "kinesisvideo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
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 == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<UpdateStreamOutput>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateStreamError::from_response(response))),
)
}
})
}
}
#[cfg(test)]
mod protocol_tests {}