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(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateGroupInput {
#[serde(rename = "Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<Vec<GroupConfigurationItem>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "ResourceQuery")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_query: Option<ResourceQuery>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateGroupOutput {
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<Group>,
#[serde(rename = "GroupConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_configuration: Option<GroupConfiguration>,
#[serde(rename = "ResourceQuery")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_query: Option<ResourceQuery>,
#[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 DeleteGroupInput {
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteGroupOutput {
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<Group>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FailedResource {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetGroupConfigurationInput {
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetGroupConfigurationOutput {
#[serde(rename = "GroupConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_configuration: Option<GroupConfiguration>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetGroupInput {
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetGroupOutput {
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<Group>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetGroupQueryInput {
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetGroupQueryOutput {
#[serde(rename = "GroupQuery")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_query: Option<GroupQuery>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetTagsInput {
#[serde(rename = "Arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetTagsOutput {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Group {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "GroupArn")]
pub group_arn: String,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GroupConfiguration {
#[serde(rename = "Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<Vec<GroupConfigurationItem>>,
#[serde(rename = "FailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "ProposedConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposed_configuration: Option<Vec<GroupConfigurationItem>>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct GroupConfigurationItem {
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<Vec<GroupConfigurationParameter>>,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct GroupConfigurationParameter {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GroupFilter {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Values")]
pub values: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GroupIdentifier {
#[serde(rename = "GroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_arn: Option<String>,
#[serde(rename = "GroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GroupQuery {
#[serde(rename = "GroupName")]
pub group_name: String,
#[serde(rename = "ResourceQuery")]
pub resource_query: ResourceQuery,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GroupResourcesInput {
#[serde(rename = "Group")]
pub group: String,
#[serde(rename = "ResourceArns")]
pub resource_arns: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GroupResourcesOutput {
#[serde(rename = "Failed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed: Option<Vec<FailedResource>>,
#[serde(rename = "Succeeded")]
#[serde(skip_serializing_if = "Option::is_none")]
pub succeeded: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListGroupResourcesInput {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<ResourceFilter>>,
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<String>,
#[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 ListGroupResourcesOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "QueryErrors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_errors: Option<Vec<QueryError>>,
#[serde(rename = "ResourceIdentifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_identifiers: Option<Vec<ResourceIdentifier>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListGroupsInput {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<GroupFilter>>,
#[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 ListGroupsOutput {
#[serde(rename = "GroupIdentifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_identifiers: Option<Vec<GroupIdentifier>>,
#[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 QueryError {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResourceFilter {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Values")]
pub values: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceIdentifier {
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResourceQuery {
#[serde(rename = "Query")]
pub query: String,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SearchResourcesInput {
#[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 = "ResourceQuery")]
pub resource_query: ResourceQuery,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SearchResourcesOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "QueryErrors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_errors: Option<Vec<QueryError>>,
#[serde(rename = "ResourceIdentifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_identifiers: Option<Vec<ResourceIdentifier>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagInput {
#[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 TagOutput {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[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 UngroupResourcesInput {
#[serde(rename = "Group")]
pub group: String,
#[serde(rename = "ResourceArns")]
pub resource_arns: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UngroupResourcesOutput {
#[serde(rename = "Failed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed: Option<Vec<FailedResource>>,
#[serde(rename = "Succeeded")]
#[serde(skip_serializing_if = "Option::is_none")]
pub succeeded: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagInput {
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "Keys")]
pub keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagOutput {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Keys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub keys: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateGroupInput {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateGroupOutput {
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<Group>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateGroupQueryInput {
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<String>,
#[serde(rename = "ResourceQuery")]
pub resource_query: ResourceQuery,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateGroupQueryOutput {
#[serde(rename = "GroupQuery")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_query: Option<GroupQuery>,
}
#[derive(Debug, PartialEq)]
pub enum CreateGroupError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
TooManyRequests(String),
}
impl CreateGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateGroupError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(CreateGroupError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(CreateGroupError::InternalServerError(err.msg))
}
"MethodNotAllowedException" => {
return RusotoError::Service(CreateGroupError::MethodNotAllowed(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateGroupError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateGroupError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateGroupError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateGroupError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateGroupError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
CreateGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteGroupError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
NotFound(String),
TooManyRequests(String),
}
impl DeleteGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteGroupError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(DeleteGroupError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DeleteGroupError::InternalServerError(err.msg))
}
"MethodNotAllowedException" => {
return RusotoError::Service(DeleteGroupError::MethodNotAllowed(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteGroupError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteGroupError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteGroupError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteGroupError::Forbidden(ref cause) => write!(f, "{}", cause),
DeleteGroupError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteGroupError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
DeleteGroupError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteGroupError {}
#[derive(Debug, PartialEq)]
pub enum GetGroupError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
NotFound(String),
TooManyRequests(String),
}
impl GetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetGroupError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(GetGroupError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetGroupError::InternalServerError(err.msg))
}
"MethodNotAllowedException" => {
return RusotoError::Service(GetGroupError::MethodNotAllowed(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetGroupError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetGroupError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetGroupError::BadRequest(ref cause) => write!(f, "{}", cause),
GetGroupError::Forbidden(ref cause) => write!(f, "{}", cause),
GetGroupError::InternalServerError(ref cause) => write!(f, "{}", cause),
GetGroupError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
GetGroupError::NotFound(ref cause) => write!(f, "{}", cause),
GetGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetGroupError {}
#[derive(Debug, PartialEq)]
pub enum GetGroupConfigurationError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
NotFound(String),
TooManyRequests(String),
}
impl GetGroupConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetGroupConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetGroupConfigurationError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(GetGroupConfigurationError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetGroupConfigurationError::InternalServerError(
err.msg,
))
}
"MethodNotAllowedException" => {
return RusotoError::Service(GetGroupConfigurationError::MethodNotAllowed(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetGroupConfigurationError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetGroupConfigurationError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetGroupConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetGroupConfigurationError::BadRequest(ref cause) => write!(f, "{}", cause),
GetGroupConfigurationError::Forbidden(ref cause) => write!(f, "{}", cause),
GetGroupConfigurationError::InternalServerError(ref cause) => write!(f, "{}", cause),
GetGroupConfigurationError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
GetGroupConfigurationError::NotFound(ref cause) => write!(f, "{}", cause),
GetGroupConfigurationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetGroupConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum GetGroupQueryError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
NotFound(String),
TooManyRequests(String),
}
impl GetGroupQueryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetGroupQueryError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetGroupQueryError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(GetGroupQueryError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetGroupQueryError::InternalServerError(err.msg))
}
"MethodNotAllowedException" => {
return RusotoError::Service(GetGroupQueryError::MethodNotAllowed(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetGroupQueryError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetGroupQueryError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetGroupQueryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetGroupQueryError::BadRequest(ref cause) => write!(f, "{}", cause),
GetGroupQueryError::Forbidden(ref cause) => write!(f, "{}", cause),
GetGroupQueryError::InternalServerError(ref cause) => write!(f, "{}", cause),
GetGroupQueryError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
GetGroupQueryError::NotFound(ref cause) => write!(f, "{}", cause),
GetGroupQueryError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetGroupQueryError {}
#[derive(Debug, PartialEq)]
pub enum GetTagsError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
NotFound(String),
TooManyRequests(String),
}
impl GetTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetTagsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetTagsError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(GetTagsError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetTagsError::InternalServerError(err.msg))
}
"MethodNotAllowedException" => {
return RusotoError::Service(GetTagsError::MethodNotAllowed(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetTagsError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetTagsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetTagsError::BadRequest(ref cause) => write!(f, "{}", cause),
GetTagsError::Forbidden(ref cause) => write!(f, "{}", cause),
GetTagsError::InternalServerError(ref cause) => write!(f, "{}", cause),
GetTagsError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
GetTagsError::NotFound(ref cause) => write!(f, "{}", cause),
GetTagsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetTagsError {}
#[derive(Debug, PartialEq)]
pub enum GroupResourcesError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
NotFound(String),
TooManyRequests(String),
}
impl GroupResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GroupResourcesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GroupResourcesError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(GroupResourcesError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GroupResourcesError::InternalServerError(err.msg))
}
"MethodNotAllowedException" => {
return RusotoError::Service(GroupResourcesError::MethodNotAllowed(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GroupResourcesError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GroupResourcesError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GroupResourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GroupResourcesError::BadRequest(ref cause) => write!(f, "{}", cause),
GroupResourcesError::Forbidden(ref cause) => write!(f, "{}", cause),
GroupResourcesError::InternalServerError(ref cause) => write!(f, "{}", cause),
GroupResourcesError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
GroupResourcesError::NotFound(ref cause) => write!(f, "{}", cause),
GroupResourcesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GroupResourcesError {}
#[derive(Debug, PartialEq)]
pub enum ListGroupResourcesError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
NotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl ListGroupResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListGroupResourcesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListGroupResourcesError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(ListGroupResourcesError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListGroupResourcesError::InternalServerError(
err.msg,
))
}
"MethodNotAllowedException" => {
return RusotoError::Service(ListGroupResourcesError::MethodNotAllowed(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListGroupResourcesError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListGroupResourcesError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListGroupResourcesError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListGroupResourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListGroupResourcesError::BadRequest(ref cause) => write!(f, "{}", cause),
ListGroupResourcesError::Forbidden(ref cause) => write!(f, "{}", cause),
ListGroupResourcesError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListGroupResourcesError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
ListGroupResourcesError::NotFound(ref cause) => write!(f, "{}", cause),
ListGroupResourcesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ListGroupResourcesError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListGroupResourcesError {}
#[derive(Debug, PartialEq)]
pub enum ListGroupsError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
TooManyRequests(String),
}
impl ListGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListGroupsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListGroupsError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(ListGroupsError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListGroupsError::InternalServerError(err.msg))
}
"MethodNotAllowedException" => {
return RusotoError::Service(ListGroupsError::MethodNotAllowed(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListGroupsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListGroupsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListGroupsError::Forbidden(ref cause) => write!(f, "{}", cause),
ListGroupsError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListGroupsError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
ListGroupsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListGroupsError {}
#[derive(Debug, PartialEq)]
pub enum SearchResourcesError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
TooManyRequests(String),
Unauthorized(String),
}
impl SearchResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SearchResourcesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(SearchResourcesError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(SearchResourcesError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(SearchResourcesError::InternalServerError(err.msg))
}
"MethodNotAllowedException" => {
return RusotoError::Service(SearchResourcesError::MethodNotAllowed(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(SearchResourcesError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(SearchResourcesError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SearchResourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SearchResourcesError::BadRequest(ref cause) => write!(f, "{}", cause),
SearchResourcesError::Forbidden(ref cause) => write!(f, "{}", cause),
SearchResourcesError::InternalServerError(ref cause) => write!(f, "{}", cause),
SearchResourcesError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
SearchResourcesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
SearchResourcesError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SearchResourcesError {}
#[derive(Debug, PartialEq)]
pub enum TagError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
NotFound(String),
TooManyRequests(String),
}
impl TagError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(TagError::BadRequest(err.msg))
}
"ForbiddenException" => return RusotoError::Service(TagError::Forbidden(err.msg)),
"InternalServerErrorException" => {
return RusotoError::Service(TagError::InternalServerError(err.msg))
}
"MethodNotAllowedException" => {
return RusotoError::Service(TagError::MethodNotAllowed(err.msg))
}
"NotFoundException" => return RusotoError::Service(TagError::NotFound(err.msg)),
"TooManyRequestsException" => {
return RusotoError::Service(TagError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagError::BadRequest(ref cause) => write!(f, "{}", cause),
TagError::Forbidden(ref cause) => write!(f, "{}", cause),
TagError::InternalServerError(ref cause) => write!(f, "{}", cause),
TagError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
TagError::NotFound(ref cause) => write!(f, "{}", cause),
TagError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagError {}
#[derive(Debug, PartialEq)]
pub enum UngroupResourcesError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
NotFound(String),
TooManyRequests(String),
}
impl UngroupResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UngroupResourcesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UngroupResourcesError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(UngroupResourcesError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UngroupResourcesError::InternalServerError(
err.msg,
))
}
"MethodNotAllowedException" => {
return RusotoError::Service(UngroupResourcesError::MethodNotAllowed(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UngroupResourcesError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UngroupResourcesError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UngroupResourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UngroupResourcesError::BadRequest(ref cause) => write!(f, "{}", cause),
UngroupResourcesError::Forbidden(ref cause) => write!(f, "{}", cause),
UngroupResourcesError::InternalServerError(ref cause) => write!(f, "{}", cause),
UngroupResourcesError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
UngroupResourcesError::NotFound(ref cause) => write!(f, "{}", cause),
UngroupResourcesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UngroupResourcesError {}
#[derive(Debug, PartialEq)]
pub enum UntagError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
NotFound(String),
TooManyRequests(String),
}
impl UntagError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UntagError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(UntagError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UntagError::InternalServerError(err.msg))
}
"MethodNotAllowedException" => {
return RusotoError::Service(UntagError::MethodNotAllowed(err.msg))
}
"NotFoundException" => return RusotoError::Service(UntagError::NotFound(err.msg)),
"TooManyRequestsException" => {
return RusotoError::Service(UntagError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagError::BadRequest(ref cause) => write!(f, "{}", cause),
UntagError::Forbidden(ref cause) => write!(f, "{}", cause),
UntagError::InternalServerError(ref cause) => write!(f, "{}", cause),
UntagError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
UntagError::NotFound(ref cause) => write!(f, "{}", cause),
UntagError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagError {}
#[derive(Debug, PartialEq)]
pub enum UpdateGroupError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateGroupError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(UpdateGroupError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateGroupError::InternalServerError(err.msg))
}
"MethodNotAllowedException" => {
return RusotoError::Service(UpdateGroupError::MethodNotAllowed(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateGroupError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateGroupError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateGroupError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateGroupError::Forbidden(ref cause) => write!(f, "{}", cause),
UpdateGroupError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateGroupError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
UpdateGroupError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateGroupError {}
#[derive(Debug, PartialEq)]
pub enum UpdateGroupQueryError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
MethodNotAllowed(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateGroupQueryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateGroupQueryError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateGroupQueryError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(UpdateGroupQueryError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateGroupQueryError::InternalServerError(
err.msg,
))
}
"MethodNotAllowedException" => {
return RusotoError::Service(UpdateGroupQueryError::MethodNotAllowed(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateGroupQueryError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateGroupQueryError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateGroupQueryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateGroupQueryError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateGroupQueryError::Forbidden(ref cause) => write!(f, "{}", cause),
UpdateGroupQueryError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateGroupQueryError::MethodNotAllowed(ref cause) => write!(f, "{}", cause),
UpdateGroupQueryError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateGroupQueryError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateGroupQueryError {}
#[async_trait]
pub trait ResourceGroups {
async fn create_group(
&self,
input: CreateGroupInput,
) -> Result<CreateGroupOutput, RusotoError<CreateGroupError>>;
async fn delete_group(
&self,
input: DeleteGroupInput,
) -> Result<DeleteGroupOutput, RusotoError<DeleteGroupError>>;
async fn get_group(
&self,
input: GetGroupInput,
) -> Result<GetGroupOutput, RusotoError<GetGroupError>>;
async fn get_group_configuration(
&self,
input: GetGroupConfigurationInput,
) -> Result<GetGroupConfigurationOutput, RusotoError<GetGroupConfigurationError>>;
async fn get_group_query(
&self,
input: GetGroupQueryInput,
) -> Result<GetGroupQueryOutput, RusotoError<GetGroupQueryError>>;
async fn get_tags(
&self,
input: GetTagsInput,
) -> Result<GetTagsOutput, RusotoError<GetTagsError>>;
async fn group_resources(
&self,
input: GroupResourcesInput,
) -> Result<GroupResourcesOutput, RusotoError<GroupResourcesError>>;
async fn list_group_resources(
&self,
input: ListGroupResourcesInput,
) -> Result<ListGroupResourcesOutput, RusotoError<ListGroupResourcesError>>;
async fn list_groups(
&self,
input: ListGroupsInput,
) -> Result<ListGroupsOutput, RusotoError<ListGroupsError>>;
async fn search_resources(
&self,
input: SearchResourcesInput,
) -> Result<SearchResourcesOutput, RusotoError<SearchResourcesError>>;
async fn tag(&self, input: TagInput) -> Result<TagOutput, RusotoError<TagError>>;
async fn ungroup_resources(
&self,
input: UngroupResourcesInput,
) -> Result<UngroupResourcesOutput, RusotoError<UngroupResourcesError>>;
async fn untag(&self, input: UntagInput) -> Result<UntagOutput, RusotoError<UntagError>>;
async fn update_group(
&self,
input: UpdateGroupInput,
) -> Result<UpdateGroupOutput, RusotoError<UpdateGroupError>>;
async fn update_group_query(
&self,
input: UpdateGroupQueryInput,
) -> Result<UpdateGroupQueryOutput, RusotoError<UpdateGroupQueryError>>;
}
#[derive(Clone)]
pub struct ResourceGroupsClient {
client: Client,
region: region::Region,
}
impl ResourceGroupsClient {
pub fn new(region: region::Region) -> ResourceGroupsClient {
ResourceGroupsClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ResourceGroupsClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ResourceGroupsClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ResourceGroupsClient {
ResourceGroupsClient { client, region }
}
}
#[async_trait]
impl ResourceGroups for ResourceGroupsClient {
#[allow(unused_mut)]
async fn create_group(
&self,
input: CreateGroupInput,
) -> Result<CreateGroupOutput, RusotoError<CreateGroupError>> {
let request_uri = "/groups";
let mut request = SignedRequest::new("POST", "resource-groups", &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::<CreateGroupOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_group(
&self,
input: DeleteGroupInput,
) -> Result<DeleteGroupOutput, RusotoError<DeleteGroupError>> {
let request_uri = "/delete-group";
let mut request = SignedRequest::new("POST", "resource-groups", &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::<DeleteGroupOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_group(
&self,
input: GetGroupInput,
) -> Result<GetGroupOutput, RusotoError<GetGroupError>> {
let request_uri = "/get-group";
let mut request = SignedRequest::new("POST", "resource-groups", &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::<GetGroupOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_group_configuration(
&self,
input: GetGroupConfigurationInput,
) -> Result<GetGroupConfigurationOutput, RusotoError<GetGroupConfigurationError>> {
let request_uri = "/get-group-configuration";
let mut request = SignedRequest::new("POST", "resource-groups", &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::<GetGroupConfigurationOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetGroupConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_group_query(
&self,
input: GetGroupQueryInput,
) -> Result<GetGroupQueryOutput, RusotoError<GetGroupQueryError>> {
let request_uri = "/get-group-query";
let mut request = SignedRequest::new("POST", "resource-groups", &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::<GetGroupQueryOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetGroupQueryError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_tags(
&self,
input: GetTagsInput,
) -> Result<GetTagsOutput, RusotoError<GetTagsError>> {
let request_uri = format!("/resources/{arn}/tags", arn = input.arn);
let mut request = SignedRequest::new("GET", "resource-groups", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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::<GetTagsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetTagsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn group_resources(
&self,
input: GroupResourcesInput,
) -> Result<GroupResourcesOutput, RusotoError<GroupResourcesError>> {
let request_uri = "/group-resources";
let mut request = SignedRequest::new("POST", "resource-groups", &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::<GroupResourcesOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GroupResourcesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_group_resources(
&self,
input: ListGroupResourcesInput,
) -> Result<ListGroupResourcesOutput, RusotoError<ListGroupResourcesError>> {
let request_uri = "/list-group-resources";
let mut request = SignedRequest::new("POST", "resource-groups", &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::<ListGroupResourcesOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListGroupResourcesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_groups(
&self,
input: ListGroupsInput,
) -> Result<ListGroupsOutput, RusotoError<ListGroupsError>> {
let request_uri = "/groups-list";
let mut request = SignedRequest::new("POST", "resource-groups", &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 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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListGroupsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListGroupsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn search_resources(
&self,
input: SearchResourcesInput,
) -> Result<SearchResourcesOutput, RusotoError<SearchResourcesError>> {
let request_uri = "/resources/search";
let mut request = SignedRequest::new("POST", "resource-groups", &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::<SearchResourcesOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(SearchResourcesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag(&self, input: TagInput) -> Result<TagOutput, RusotoError<TagError>> {
let request_uri = format!("/resources/{arn}/tags", arn = input.arn);
let mut request = SignedRequest::new("PUT", "resource-groups", &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::<TagOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagError::from_response(response))
}
}
#[allow(unused_mut)]
async fn ungroup_resources(
&self,
input: UngroupResourcesInput,
) -> Result<UngroupResourcesOutput, RusotoError<UngroupResourcesError>> {
let request_uri = "/ungroup-resources";
let mut request = SignedRequest::new("POST", "resource-groups", &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::<UngroupResourcesOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UngroupResourcesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag(&self, input: UntagInput) -> Result<UntagOutput, RusotoError<UntagError>> {
let request_uri = format!("/resources/{arn}/tags", arn = input.arn);
let mut request =
SignedRequest::new("PATCH", "resource-groups", &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::<UntagOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_group(
&self,
input: UpdateGroupInput,
) -> Result<UpdateGroupOutput, RusotoError<UpdateGroupError>> {
let request_uri = "/update-group";
let mut request = SignedRequest::new("POST", "resource-groups", &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::<UpdateGroupOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_group_query(
&self,
input: UpdateGroupQueryInput,
) -> Result<UpdateGroupQueryOutput, RusotoError<UpdateGroupQueryError>> {
let request_uri = "/update-group-query";
let mut request = SignedRequest::new("POST", "resource-groups", &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::<UpdateGroupQueryOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateGroupQueryError::from_response(response))
}
}
}