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(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateNotificationRuleRequest {
#[serde(rename = "ClientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "DetailType")]
pub detail_type: String,
#[serde(rename = "EventTypeIds")]
pub event_type_ids: Vec<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Resource")]
pub resource: String,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Targets")]
pub targets: Vec<Target>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateNotificationRuleResult {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteNotificationRuleRequest {
#[serde(rename = "Arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteNotificationRuleResult {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTargetRequest {
#[serde(rename = "ForceUnsubscribeAll")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force_unsubscribe_all: Option<bool>,
#[serde(rename = "TargetAddress")]
pub target_address: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTargetResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeNotificationRuleRequest {
#[serde(rename = "Arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeNotificationRuleResult {
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "CreatedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_by: Option<String>,
#[serde(rename = "CreatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_timestamp: Option<f64>,
#[serde(rename = "DetailType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detail_type: Option<String>,
#[serde(rename = "EventTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_types: Option<Vec<EventTypeSummary>>,
#[serde(rename = "LastModifiedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_timestamp: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Resource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Targets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub targets: Option<Vec<TargetSummary>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EventTypeSummary {
#[serde(rename = "EventTypeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_type_id: Option<String>,
#[serde(rename = "EventTypeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_type_name: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "ServiceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListEventTypesFilter {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListEventTypesRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<ListEventTypesFilter>>,
#[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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListEventTypesResult {
#[serde(rename = "EventTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_types: Option<Vec<EventTypeSummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListNotificationRulesFilter {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListNotificationRulesRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<ListNotificationRulesFilter>>,
#[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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListNotificationRulesResult {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "NotificationRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_rules: Option<Vec<NotificationRuleSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "Arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResult {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTargetsFilter {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTargetsRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<ListTargetsFilter>>,
#[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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTargetsResult {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Targets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub targets: Option<Vec<TargetSummary>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NotificationRuleSummary {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SubscribeRequest {
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "ClientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "Target")]
pub target: Target,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SubscribeResult {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "Tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResult {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Target {
#[serde(rename = "TargetAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_address: Option<String>,
#[serde(rename = "TargetType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TargetSummary {
#[serde(rename = "TargetAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_address: Option<String>,
#[serde(rename = "TargetStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_status: Option<String>,
#[serde(rename = "TargetType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UnsubscribeRequest {
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "TargetAddress")]
pub target_address: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UnsubscribeResult {
#[serde(rename = "Arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateNotificationRuleRequest {
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "DetailType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detail_type: Option<String>,
#[serde(rename = "EventTypeIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_type_ids: Option<Vec<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>,
#[serde(rename = "Targets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub targets: Option<Vec<Target>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateNotificationRuleResult {}
#[derive(Debug, PartialEq)]
pub enum CreateNotificationRuleError {
AccessDenied(String),
ConcurrentModification(String),
Configuration(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
}
impl CreateNotificationRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateNotificationRuleError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateNotificationRuleError::AccessDenied(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(
CreateNotificationRuleError::ConcurrentModification(err.msg),
)
}
"ConfigurationException" => {
return RusotoError::Service(CreateNotificationRuleError::Configuration(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateNotificationRuleError::LimitExceeded(
err.msg,
))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
CreateNotificationRuleError::ResourceAlreadyExists(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateNotificationRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateNotificationRuleError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateNotificationRuleError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
CreateNotificationRuleError::Configuration(ref cause) => write!(f, "{}", cause),
CreateNotificationRuleError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateNotificationRuleError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateNotificationRuleError {}
#[derive(Debug, PartialEq)]
pub enum DeleteNotificationRuleError {
ConcurrentModification(String),
LimitExceeded(String),
}
impl DeleteNotificationRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteNotificationRuleError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(
DeleteNotificationRuleError::ConcurrentModification(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(DeleteNotificationRuleError::LimitExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteNotificationRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteNotificationRuleError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
DeleteNotificationRuleError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteNotificationRuleError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTargetError {}
impl DeleteTargetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTargetError> {
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 DeleteTargetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DeleteTargetError {}
#[derive(Debug, PartialEq)]
pub enum DescribeNotificationRuleError {
ResourceNotFound(String),
}
impl DescribeNotificationRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeNotificationRuleError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeNotificationRuleError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeNotificationRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeNotificationRuleError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeNotificationRuleError {}
#[derive(Debug, PartialEq)]
pub enum ListEventTypesError {
InvalidNextToken(String),
}
impl ListEventTypesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListEventTypesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListEventTypesError::InvalidNextToken(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListEventTypesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListEventTypesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListEventTypesError {}
#[derive(Debug, PartialEq)]
pub enum ListNotificationRulesError {
InvalidNextToken(String),
}
impl ListNotificationRulesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListNotificationRulesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListNotificationRulesError::InvalidNextToken(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListNotificationRulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListNotificationRulesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListNotificationRulesError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
ResourceNotFound(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() {
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
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::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListTargetsError {
InvalidNextToken(String),
}
impl ListTargetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTargetsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListTargetsError::InvalidNextToken(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTargetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTargetsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTargetsError {}
#[derive(Debug, PartialEq)]
pub enum SubscribeError {
ResourceNotFound(String),
}
impl SubscribeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SubscribeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(SubscribeError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SubscribeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SubscribeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SubscribeError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
ConcurrentModification(String),
ResourceNotFound(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() {
"ConcurrentModificationException" => {
return RusotoError::Service(TagResourceError::ConcurrentModification(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(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::ConcurrentModification(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UnsubscribeError {}
impl UnsubscribeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UnsubscribeError> {
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 UnsubscribeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for UnsubscribeError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
ConcurrentModification(String),
ResourceNotFound(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() {
"ConcurrentModificationException" => {
return RusotoError::Service(UntagResourceError::ConcurrentModification(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(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::ConcurrentModification(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateNotificationRuleError {
ResourceNotFound(String),
}
impl UpdateNotificationRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateNotificationRuleError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateNotificationRuleError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateNotificationRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateNotificationRuleError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateNotificationRuleError {}
#[async_trait]
pub trait CodeStarNotifications {
async fn create_notification_rule(
&self,
input: CreateNotificationRuleRequest,
) -> Result<CreateNotificationRuleResult, RusotoError<CreateNotificationRuleError>>;
async fn delete_notification_rule(
&self,
input: DeleteNotificationRuleRequest,
) -> Result<DeleteNotificationRuleResult, RusotoError<DeleteNotificationRuleError>>;
async fn delete_target(
&self,
input: DeleteTargetRequest,
) -> Result<DeleteTargetResult, RusotoError<DeleteTargetError>>;
async fn describe_notification_rule(
&self,
input: DescribeNotificationRuleRequest,
) -> Result<DescribeNotificationRuleResult, RusotoError<DescribeNotificationRuleError>>;
async fn list_event_types(
&self,
input: ListEventTypesRequest,
) -> Result<ListEventTypesResult, RusotoError<ListEventTypesError>>;
async fn list_notification_rules(
&self,
input: ListNotificationRulesRequest,
) -> Result<ListNotificationRulesResult, RusotoError<ListNotificationRulesError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResult, RusotoError<ListTagsForResourceError>>;
async fn list_targets(
&self,
input: ListTargetsRequest,
) -> Result<ListTargetsResult, RusotoError<ListTargetsError>>;
async fn subscribe(
&self,
input: SubscribeRequest,
) -> Result<SubscribeResult, RusotoError<SubscribeError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResult, RusotoError<TagResourceError>>;
async fn unsubscribe(
&self,
input: UnsubscribeRequest,
) -> Result<UnsubscribeResult, RusotoError<UnsubscribeError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResult, RusotoError<UntagResourceError>>;
async fn update_notification_rule(
&self,
input: UpdateNotificationRuleRequest,
) -> Result<UpdateNotificationRuleResult, RusotoError<UpdateNotificationRuleError>>;
}
#[derive(Clone)]
pub struct CodeStarNotificationsClient {
client: Client,
region: region::Region,
}
impl CodeStarNotificationsClient {
pub fn new(region: region::Region) -> CodeStarNotificationsClient {
CodeStarNotificationsClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CodeStarNotificationsClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
CodeStarNotificationsClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> CodeStarNotificationsClient {
CodeStarNotificationsClient { client, region }
}
}
#[async_trait]
impl CodeStarNotifications for CodeStarNotificationsClient {
#[allow(unused_mut)]
async fn create_notification_rule(
&self,
input: CreateNotificationRuleRequest,
) -> Result<CreateNotificationRuleResult, RusotoError<CreateNotificationRuleError>> {
let request_uri = "/createNotificationRule";
let mut request =
SignedRequest::new("POST", "codestar-notifications", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateNotificationRuleResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateNotificationRuleError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_notification_rule(
&self,
input: DeleteNotificationRuleRequest,
) -> Result<DeleteNotificationRuleResult, RusotoError<DeleteNotificationRuleError>> {
let request_uri = "/deleteNotificationRule";
let mut request =
SignedRequest::new("POST", "codestar-notifications", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteNotificationRuleResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteNotificationRuleError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_target(
&self,
input: DeleteTargetRequest,
) -> Result<DeleteTargetResult, RusotoError<DeleteTargetError>> {
let request_uri = "/deleteTarget";
let mut request =
SignedRequest::new("POST", "codestar-notifications", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteTargetResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteTargetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_notification_rule(
&self,
input: DescribeNotificationRuleRequest,
) -> Result<DescribeNotificationRuleResult, RusotoError<DescribeNotificationRuleError>> {
let request_uri = "/describeNotificationRule";
let mut request =
SignedRequest::new("POST", "codestar-notifications", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeNotificationRuleResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeNotificationRuleError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_event_types(
&self,
input: ListEventTypesRequest,
) -> Result<ListEventTypesResult, RusotoError<ListEventTypesError>> {
let request_uri = "/listEventTypes";
let mut request =
SignedRequest::new("POST", "codestar-notifications", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListEventTypesResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListEventTypesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_notification_rules(
&self,
input: ListNotificationRulesRequest,
) -> Result<ListNotificationRulesResult, RusotoError<ListNotificationRulesError>> {
let request_uri = "/listNotificationRules";
let mut request =
SignedRequest::new("POST", "codestar-notifications", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListNotificationRulesResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListNotificationRulesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResult, RusotoError<ListTagsForResourceError>> {
let request_uri = "/listTagsForResource";
let mut request =
SignedRequest::new("POST", "codestar-notifications", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_targets(
&self,
input: ListTargetsRequest,
) -> Result<ListTargetsResult, RusotoError<ListTargetsError>> {
let request_uri = "/listTargets";
let mut request =
SignedRequest::new("POST", "codestar-notifications", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTargetsResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTargetsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn subscribe(
&self,
input: SubscribeRequest,
) -> Result<SubscribeResult, RusotoError<SubscribeError>> {
let request_uri = "/subscribe";
let mut request =
SignedRequest::new("POST", "codestar-notifications", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<SubscribeResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(SubscribeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResult, RusotoError<TagResourceError>> {
let request_uri = "/tagResource";
let mut request =
SignedRequest::new("POST", "codestar-notifications", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<TagResourceResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn unsubscribe(
&self,
input: UnsubscribeRequest,
) -> Result<UnsubscribeResult, RusotoError<UnsubscribeError>> {
let request_uri = "/unsubscribe";
let mut request =
SignedRequest::new("POST", "codestar-notifications", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UnsubscribeResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UnsubscribeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResult, RusotoError<UntagResourceError>> {
let request_uri = "/untagResource";
let mut request =
SignedRequest::new("POST", "codestar-notifications", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UntagResourceResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_notification_rule(
&self,
input: UpdateNotificationRuleRequest,
) -> Result<UpdateNotificationRuleResult, RusotoError<UpdateNotificationRuleError>> {
let request_uri = "/updateNotificationRule";
let mut request =
SignedRequest::new("POST", "codestar-notifications", &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);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateNotificationRuleResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateNotificationRuleError::from_response(response))
}
}
}