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::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl Cloud9Client {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "cloud9", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateEnvironmentEC2Request {
#[serde(rename = "automaticStopTimeMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub automatic_stop_time_minutes: Option<i64>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "instanceType")]
pub instance_type: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "ownerArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_arn: Option<String>,
#[serde(rename = "subnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateEnvironmentEC2Result {
#[serde(rename = "environmentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateEnvironmentMembershipRequest {
#[serde(rename = "environmentId")]
pub environment_id: String,
#[serde(rename = "permissions")]
pub permissions: String,
#[serde(rename = "userArn")]
pub user_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateEnvironmentMembershipResult {
#[serde(rename = "membership")]
#[serde(skip_serializing_if = "Option::is_none")]
pub membership: Option<EnvironmentMember>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteEnvironmentMembershipRequest {
#[serde(rename = "environmentId")]
pub environment_id: String,
#[serde(rename = "userArn")]
pub user_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteEnvironmentMembershipResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteEnvironmentRequest {
#[serde(rename = "environmentId")]
pub environment_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteEnvironmentResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEnvironmentMembershipsRequest {
#[serde(rename = "environmentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_id: 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>,
#[serde(rename = "permissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions: Option<Vec<String>>,
#[serde(rename = "userArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeEnvironmentMembershipsResult {
#[serde(rename = "memberships")]
#[serde(skip_serializing_if = "Option::is_none")]
pub memberships: Option<Vec<EnvironmentMember>>,
#[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 DescribeEnvironmentStatusRequest {
#[serde(rename = "environmentId")]
pub environment_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeEnvironmentStatusResult {
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeEnvironmentsRequest {
#[serde(rename = "environmentIds")]
pub environment_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeEnvironmentsResult {
#[serde(rename = "environments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environments: Option<Vec<Environment>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Environment {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "lifecycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle: Option<EnvironmentLifecycle>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ownerArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_arn: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnvironmentLifecycle {
#[serde(rename = "failureResource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_resource: Option<String>,
#[serde(rename = "reason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnvironmentMember {
#[serde(rename = "environmentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_id: Option<String>,
#[serde(rename = "lastAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_access: Option<f64>,
#[serde(rename = "permissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions: Option<String>,
#[serde(rename = "userArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_arn: Option<String>,
#[serde(rename = "userId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListEnvironmentsRequest {
#[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 ListEnvironmentsResult {
#[serde(rename = "environmentIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_ids: Option<Vec<String>>,
#[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 ListTagsForResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateEnvironmentMembershipRequest {
#[serde(rename = "environmentId")]
pub environment_id: String,
#[serde(rename = "permissions")]
pub permissions: String,
#[serde(rename = "userArn")]
pub user_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateEnvironmentMembershipResult {
#[serde(rename = "membership")]
#[serde(skip_serializing_if = "Option::is_none")]
pub membership: Option<EnvironmentMember>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateEnvironmentRequest {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "environmentId")]
pub environment_id: String,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateEnvironmentResult {}
#[derive(Debug, PartialEq)]
pub enum CreateEnvironmentEC2Error {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
LimitExceeded(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateEnvironmentEC2Error {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateEnvironmentEC2Error> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateEnvironmentEC2Error::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateEnvironmentEC2Error::Conflict(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(CreateEnvironmentEC2Error::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(CreateEnvironmentEC2Error::InternalServerError(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateEnvironmentEC2Error::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateEnvironmentEC2Error::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateEnvironmentEC2Error::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateEnvironmentEC2Error {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateEnvironmentEC2Error::BadRequest(ref cause) => write!(f, "{}", cause),
CreateEnvironmentEC2Error::Conflict(ref cause) => write!(f, "{}", cause),
CreateEnvironmentEC2Error::Forbidden(ref cause) => write!(f, "{}", cause),
CreateEnvironmentEC2Error::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateEnvironmentEC2Error::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateEnvironmentEC2Error::NotFound(ref cause) => write!(f, "{}", cause),
CreateEnvironmentEC2Error::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateEnvironmentEC2Error {}
#[derive(Debug, PartialEq)]
pub enum CreateEnvironmentMembershipError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
LimitExceeded(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateEnvironmentMembershipError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateEnvironmentMembershipError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateEnvironmentMembershipError::BadRequest(
err.msg,
))
}
"ConflictException" => {
return RusotoError::Service(CreateEnvironmentMembershipError::Conflict(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(CreateEnvironmentMembershipError::Forbidden(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
CreateEnvironmentMembershipError::InternalServerError(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(CreateEnvironmentMembershipError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(CreateEnvironmentMembershipError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateEnvironmentMembershipError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateEnvironmentMembershipError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateEnvironmentMembershipError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateEnvironmentMembershipError::Conflict(ref cause) => write!(f, "{}", cause),
CreateEnvironmentMembershipError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateEnvironmentMembershipError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
CreateEnvironmentMembershipError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateEnvironmentMembershipError::NotFound(ref cause) => write!(f, "{}", cause),
CreateEnvironmentMembershipError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateEnvironmentMembershipError {}
#[derive(Debug, PartialEq)]
pub enum DeleteEnvironmentError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
LimitExceeded(String),
NotFound(String),
TooManyRequests(String),
}
impl DeleteEnvironmentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteEnvironmentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteEnvironmentError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(DeleteEnvironmentError::Conflict(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(DeleteEnvironmentError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DeleteEnvironmentError::InternalServerError(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteEnvironmentError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteEnvironmentError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteEnvironmentError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteEnvironmentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteEnvironmentError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentError::Conflict(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentError::Forbidden(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteEnvironmentError {}
#[derive(Debug, PartialEq)]
pub enum DeleteEnvironmentMembershipError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
LimitExceeded(String),
NotFound(String),
TooManyRequests(String),
}
impl DeleteEnvironmentMembershipError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteEnvironmentMembershipError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteEnvironmentMembershipError::BadRequest(
err.msg,
))
}
"ConflictException" => {
return RusotoError::Service(DeleteEnvironmentMembershipError::Conflict(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(DeleteEnvironmentMembershipError::Forbidden(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
DeleteEnvironmentMembershipError::InternalServerError(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(DeleteEnvironmentMembershipError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DeleteEnvironmentMembershipError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteEnvironmentMembershipError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteEnvironmentMembershipError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteEnvironmentMembershipError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentMembershipError::Conflict(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentMembershipError::Forbidden(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentMembershipError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DeleteEnvironmentMembershipError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentMembershipError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteEnvironmentMembershipError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteEnvironmentMembershipError {}
#[derive(Debug, PartialEq)]
pub enum DescribeEnvironmentMembershipsError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
LimitExceeded(String),
NotFound(String),
TooManyRequests(String),
}
impl DescribeEnvironmentMembershipsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeEnvironmentMembershipsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DescribeEnvironmentMembershipsError::BadRequest(
err.msg,
))
}
"ConflictException" => {
return RusotoError::Service(DescribeEnvironmentMembershipsError::Conflict(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(DescribeEnvironmentMembershipsError::Forbidden(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
DescribeEnvironmentMembershipsError::InternalServerError(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
DescribeEnvironmentMembershipsError::LimitExceeded(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(DescribeEnvironmentMembershipsError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
DescribeEnvironmentMembershipsError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeEnvironmentMembershipsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeEnvironmentMembershipsError::BadRequest(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentMembershipsError::Conflict(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentMembershipsError::Forbidden(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentMembershipsError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeEnvironmentMembershipsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentMembershipsError::NotFound(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentMembershipsError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeEnvironmentMembershipsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeEnvironmentStatusError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
LimitExceeded(String),
NotFound(String),
TooManyRequests(String),
}
impl DescribeEnvironmentStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeEnvironmentStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DescribeEnvironmentStatusError::BadRequest(
err.msg,
))
}
"ConflictException" => {
return RusotoError::Service(DescribeEnvironmentStatusError::Conflict(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(DescribeEnvironmentStatusError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(
DescribeEnvironmentStatusError::InternalServerError(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(DescribeEnvironmentStatusError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DescribeEnvironmentStatusError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeEnvironmentStatusError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeEnvironmentStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeEnvironmentStatusError::BadRequest(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentStatusError::Conflict(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentStatusError::Forbidden(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentStatusError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeEnvironmentStatusError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentStatusError::NotFound(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentStatusError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeEnvironmentStatusError {}
#[derive(Debug, PartialEq)]
pub enum DescribeEnvironmentsError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
LimitExceeded(String),
NotFound(String),
TooManyRequests(String),
}
impl DescribeEnvironmentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeEnvironmentsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DescribeEnvironmentsError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(DescribeEnvironmentsError::Conflict(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(DescribeEnvironmentsError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DescribeEnvironmentsError::InternalServerError(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(DescribeEnvironmentsError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DescribeEnvironmentsError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeEnvironmentsError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeEnvironmentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeEnvironmentsError::BadRequest(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentsError::Conflict(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentsError::Forbidden(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentsError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentsError::NotFound(ref cause) => write!(f, "{}", cause),
DescribeEnvironmentsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeEnvironmentsError {}
#[derive(Debug, PartialEq)]
pub enum ListEnvironmentsError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
LimitExceeded(String),
NotFound(String),
TooManyRequests(String),
}
impl ListEnvironmentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListEnvironmentsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListEnvironmentsError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(ListEnvironmentsError::Conflict(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(ListEnvironmentsError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListEnvironmentsError::InternalServerError(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListEnvironmentsError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListEnvironmentsError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListEnvironmentsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListEnvironmentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListEnvironmentsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListEnvironmentsError::Conflict(ref cause) => write!(f, "{}", cause),
ListEnvironmentsError::Forbidden(ref cause) => write!(f, "{}", cause),
ListEnvironmentsError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListEnvironmentsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListEnvironmentsError::NotFound(ref cause) => write!(f, "{}", cause),
ListEnvironmentsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListEnvironmentsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
BadRequest(String),
InternalServerError(String),
NotFound(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListTagsForResourceError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListTagsForResourceError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
BadRequest(String),
InternalServerError(String),
NotFound(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(TagResourceError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(TagResourceError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(TagResourceError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
TagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
BadRequest(String),
InternalServerError(String),
NotFound(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UntagResourceError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UntagResourceError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UntagResourceError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
UntagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateEnvironmentError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
LimitExceeded(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateEnvironmentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateEnvironmentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateEnvironmentError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateEnvironmentError::Conflict(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(UpdateEnvironmentError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateEnvironmentError::InternalServerError(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateEnvironmentError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateEnvironmentError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateEnvironmentError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateEnvironmentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateEnvironmentError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateEnvironmentError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateEnvironmentError::Forbidden(ref cause) => write!(f, "{}", cause),
UpdateEnvironmentError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateEnvironmentError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateEnvironmentError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateEnvironmentError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateEnvironmentError {}
#[derive(Debug, PartialEq)]
pub enum UpdateEnvironmentMembershipError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
LimitExceeded(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateEnvironmentMembershipError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateEnvironmentMembershipError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateEnvironmentMembershipError::BadRequest(
err.msg,
))
}
"ConflictException" => {
return RusotoError::Service(UpdateEnvironmentMembershipError::Conflict(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(UpdateEnvironmentMembershipError::Forbidden(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
UpdateEnvironmentMembershipError::InternalServerError(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(UpdateEnvironmentMembershipError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdateEnvironmentMembershipError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateEnvironmentMembershipError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateEnvironmentMembershipError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateEnvironmentMembershipError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateEnvironmentMembershipError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateEnvironmentMembershipError::Forbidden(ref cause) => write!(f, "{}", cause),
UpdateEnvironmentMembershipError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
UpdateEnvironmentMembershipError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateEnvironmentMembershipError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateEnvironmentMembershipError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateEnvironmentMembershipError {}
#[async_trait]
pub trait Cloud9 {
async fn create_environment_ec2(
&self,
input: CreateEnvironmentEC2Request,
) -> Result<CreateEnvironmentEC2Result, RusotoError<CreateEnvironmentEC2Error>>;
async fn create_environment_membership(
&self,
input: CreateEnvironmentMembershipRequest,
) -> Result<CreateEnvironmentMembershipResult, RusotoError<CreateEnvironmentMembershipError>>;
async fn delete_environment(
&self,
input: DeleteEnvironmentRequest,
) -> Result<DeleteEnvironmentResult, RusotoError<DeleteEnvironmentError>>;
async fn delete_environment_membership(
&self,
input: DeleteEnvironmentMembershipRequest,
) -> Result<DeleteEnvironmentMembershipResult, RusotoError<DeleteEnvironmentMembershipError>>;
async fn describe_environment_memberships(
&self,
input: DescribeEnvironmentMembershipsRequest,
) -> Result<
DescribeEnvironmentMembershipsResult,
RusotoError<DescribeEnvironmentMembershipsError>,
>;
async fn describe_environment_status(
&self,
input: DescribeEnvironmentStatusRequest,
) -> Result<DescribeEnvironmentStatusResult, RusotoError<DescribeEnvironmentStatusError>>;
async fn describe_environments(
&self,
input: DescribeEnvironmentsRequest,
) -> Result<DescribeEnvironmentsResult, RusotoError<DescribeEnvironmentsError>>;
async fn list_environments(
&self,
input: ListEnvironmentsRequest,
) -> Result<ListEnvironmentsResult, RusotoError<ListEnvironmentsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_environment(
&self,
input: UpdateEnvironmentRequest,
) -> Result<UpdateEnvironmentResult, RusotoError<UpdateEnvironmentError>>;
async fn update_environment_membership(
&self,
input: UpdateEnvironmentMembershipRequest,
) -> Result<UpdateEnvironmentMembershipResult, RusotoError<UpdateEnvironmentMembershipError>>;
}
#[derive(Clone)]
pub struct Cloud9Client {
client: Client,
region: region::Region,
}
impl Cloud9Client {
pub fn new(region: region::Region) -> Cloud9Client {
Cloud9Client {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> Cloud9Client
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
Cloud9Client {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> Cloud9Client {
Cloud9Client { client, region }
}
}
#[async_trait]
impl Cloud9 for Cloud9Client {
async fn create_environment_ec2(
&self,
input: CreateEnvironmentEC2Request,
) -> Result<CreateEnvironmentEC2Result, RusotoError<CreateEnvironmentEC2Error>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCloud9WorkspaceManagementService.CreateEnvironmentEC2",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateEnvironmentEC2Error::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateEnvironmentEC2Result, _>()
}
async fn create_environment_membership(
&self,
input: CreateEnvironmentMembershipRequest,
) -> Result<CreateEnvironmentMembershipResult, RusotoError<CreateEnvironmentMembershipError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCloud9WorkspaceManagementService.CreateEnvironmentMembership",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateEnvironmentMembershipError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateEnvironmentMembershipResult, _>()
}
async fn delete_environment(
&self,
input: DeleteEnvironmentRequest,
) -> Result<DeleteEnvironmentResult, RusotoError<DeleteEnvironmentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCloud9WorkspaceManagementService.DeleteEnvironment",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteEnvironmentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteEnvironmentResult, _>()
}
async fn delete_environment_membership(
&self,
input: DeleteEnvironmentMembershipRequest,
) -> Result<DeleteEnvironmentMembershipResult, RusotoError<DeleteEnvironmentMembershipError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCloud9WorkspaceManagementService.DeleteEnvironmentMembership",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteEnvironmentMembershipError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteEnvironmentMembershipResult, _>()
}
async fn describe_environment_memberships(
&self,
input: DescribeEnvironmentMembershipsRequest,
) -> Result<
DescribeEnvironmentMembershipsResult,
RusotoError<DescribeEnvironmentMembershipsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCloud9WorkspaceManagementService.DescribeEnvironmentMemberships",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeEnvironmentMembershipsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeEnvironmentMembershipsResult, _>()
}
async fn describe_environment_status(
&self,
input: DescribeEnvironmentStatusRequest,
) -> Result<DescribeEnvironmentStatusResult, RusotoError<DescribeEnvironmentStatusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCloud9WorkspaceManagementService.DescribeEnvironmentStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeEnvironmentStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeEnvironmentStatusResult, _>()
}
async fn describe_environments(
&self,
input: DescribeEnvironmentsRequest,
) -> Result<DescribeEnvironmentsResult, RusotoError<DescribeEnvironmentsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCloud9WorkspaceManagementService.DescribeEnvironments",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeEnvironmentsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeEnvironmentsResult, _>()
}
async fn list_environments(
&self,
input: ListEnvironmentsRequest,
) -> Result<ListEnvironmentsResult, RusotoError<ListEnvironmentsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCloud9WorkspaceManagementService.ListEnvironments",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListEnvironmentsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListEnvironmentsResult, _>()
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCloud9WorkspaceManagementService.ListTagsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceResponse, _>()
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCloud9WorkspaceManagementService.TagResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceResponse, _>()
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCloud9WorkspaceManagementService.UntagResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceResponse, _>()
}
async fn update_environment(
&self,
input: UpdateEnvironmentRequest,
) -> Result<UpdateEnvironmentResult, RusotoError<UpdateEnvironmentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCloud9WorkspaceManagementService.UpdateEnvironment",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateEnvironmentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateEnvironmentResult, _>()
}
async fn update_environment_membership(
&self,
input: UpdateEnvironmentMembershipRequest,
) -> Result<UpdateEnvironmentMembershipResult, RusotoError<UpdateEnvironmentMembershipError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCloud9WorkspaceManagementService.UpdateEnvironmentMembership",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateEnvironmentMembershipError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateEnvironmentMembershipResult, _>()
}
}