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 AssociateDeviceWithPlacementRequest {
#[serde(rename = "deviceId")]
pub device_id: String,
#[serde(rename = "deviceTemplateName")]
pub device_template_name: String,
#[serde(rename = "placementName")]
pub placement_name: String,
#[serde(rename = "projectName")]
pub project_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateDeviceWithPlacementResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePlacementRequest {
#[serde(rename = "attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "placementName")]
pub placement_name: String,
#[serde(rename = "projectName")]
pub project_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreatePlacementResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateProjectRequest {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "placementTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub placement_template: Option<PlacementTemplate>,
#[serde(rename = "projectName")]
pub project_name: 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 CreateProjectResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePlacementRequest {
#[serde(rename = "placementName")]
pub placement_name: String,
#[serde(rename = "projectName")]
pub project_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeletePlacementResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteProjectRequest {
#[serde(rename = "projectName")]
pub project_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteProjectResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePlacementRequest {
#[serde(rename = "placementName")]
pub placement_name: String,
#[serde(rename = "projectName")]
pub project_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribePlacementResponse {
#[serde(rename = "placement")]
pub placement: PlacementDescription,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeProjectRequest {
#[serde(rename = "projectName")]
pub project_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeProjectResponse {
#[serde(rename = "project")]
pub project: ProjectDescription,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeviceTemplate {
#[serde(rename = "callbackOverrides")]
#[serde(skip_serializing_if = "Option::is_none")]
pub callback_overrides: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "deviceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateDeviceFromPlacementRequest {
#[serde(rename = "deviceTemplateName")]
pub device_template_name: String,
#[serde(rename = "placementName")]
pub placement_name: String,
#[serde(rename = "projectName")]
pub project_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateDeviceFromPlacementResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDevicesInPlacementRequest {
#[serde(rename = "placementName")]
pub placement_name: String,
#[serde(rename = "projectName")]
pub project_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDevicesInPlacementResponse {
#[serde(rename = "devices")]
pub devices: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPlacementsRequest {
#[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 = "projectName")]
pub project_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPlacementsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "placements")]
pub placements: Vec<PlacementSummary>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListProjectsRequest {
#[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 ListProjectsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "projects")]
pub projects: Vec<ProjectSummary>,
}
#[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<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PlacementDescription {
#[serde(rename = "attributes")]
pub attributes: ::std::collections::HashMap<String, String>,
#[serde(rename = "createdDate")]
pub created_date: f64,
#[serde(rename = "placementName")]
pub placement_name: String,
#[serde(rename = "projectName")]
pub project_name: String,
#[serde(rename = "updatedDate")]
pub updated_date: f64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PlacementSummary {
#[serde(rename = "createdDate")]
pub created_date: f64,
#[serde(rename = "placementName")]
pub placement_name: String,
#[serde(rename = "projectName")]
pub project_name: String,
#[serde(rename = "updatedDate")]
pub updated_date: f64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct PlacementTemplate {
#[serde(rename = "defaultAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "deviceTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_templates: Option<::std::collections::HashMap<String, DeviceTemplate>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProjectDescription {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdDate")]
pub created_date: f64,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "placementTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub placement_template: Option<PlacementTemplate>,
#[serde(rename = "projectName")]
pub project_name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "updatedDate")]
pub updated_date: f64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProjectSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdDate")]
pub created_date: f64,
#[serde(rename = "projectName")]
pub project_name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "updatedDate")]
pub updated_date: f64,
}
#[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: ::std::collections::HashMap<String, String>,
}
#[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 UpdatePlacementRequest {
#[serde(rename = "attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "placementName")]
pub placement_name: String,
#[serde(rename = "projectName")]
pub project_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdatePlacementResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateProjectRequest {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "placementTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub placement_template: Option<PlacementTemplate>,
#[serde(rename = "projectName")]
pub project_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateProjectResponse {}
#[derive(Debug, PartialEq)]
pub enum AssociateDeviceWithPlacementError {
InternalFailure(String),
InvalidRequest(String),
ResourceConflict(String),
ResourceNotFound(String),
}
impl AssociateDeviceWithPlacementError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateDeviceWithPlacementError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(
AssociateDeviceWithPlacementError::InternalFailure(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(AssociateDeviceWithPlacementError::InvalidRequest(
err.msg,
))
}
"ResourceConflictException" => {
return RusotoError::Service(
AssociateDeviceWithPlacementError::ResourceConflict(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AssociateDeviceWithPlacementError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateDeviceWithPlacementError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateDeviceWithPlacementError::InternalFailure(ref cause) => write!(f, "{}", cause),
AssociateDeviceWithPlacementError::InvalidRequest(ref cause) => write!(f, "{}", cause),
AssociateDeviceWithPlacementError::ResourceConflict(ref cause) => {
write!(f, "{}", cause)
}
AssociateDeviceWithPlacementError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateDeviceWithPlacementError {}
#[derive(Debug, PartialEq)]
pub enum CreatePlacementError {
InternalFailure(String),
InvalidRequest(String),
ResourceConflict(String),
ResourceNotFound(String),
}
impl CreatePlacementError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePlacementError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(CreatePlacementError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreatePlacementError::InvalidRequest(err.msg))
}
"ResourceConflictException" => {
return RusotoError::Service(CreatePlacementError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreatePlacementError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreatePlacementError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePlacementError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreatePlacementError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreatePlacementError::ResourceConflict(ref cause) => write!(f, "{}", cause),
CreatePlacementError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreatePlacementError {}
#[derive(Debug, PartialEq)]
pub enum CreateProjectError {
InternalFailure(String),
InvalidRequest(String),
ResourceConflict(String),
}
impl CreateProjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateProjectError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(CreateProjectError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateProjectError::InvalidRequest(err.msg))
}
"ResourceConflictException" => {
return RusotoError::Service(CreateProjectError::ResourceConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateProjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateProjectError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateProjectError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateProjectError::ResourceConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateProjectError {}
#[derive(Debug, PartialEq)]
pub enum DeletePlacementError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DeletePlacementError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeletePlacementError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeletePlacementError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeletePlacementError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeletePlacementError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeletePlacementError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeletePlacementError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeletePlacementError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeletePlacementError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeletePlacementError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeletePlacementError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeletePlacementError {}
#[derive(Debug, PartialEq)]
pub enum DeleteProjectError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DeleteProjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteProjectError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeleteProjectError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteProjectError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteProjectError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteProjectError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteProjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteProjectError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteProjectError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteProjectError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteProjectError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteProjectError {}
#[derive(Debug, PartialEq)]
pub enum DescribePlacementError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl DescribePlacementError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribePlacementError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DescribePlacementError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribePlacementError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribePlacementError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribePlacementError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribePlacementError::InternalFailure(ref cause) => write!(f, "{}", cause),
DescribePlacementError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribePlacementError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribePlacementError {}
#[derive(Debug, PartialEq)]
pub enum DescribeProjectError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl DescribeProjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeProjectError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DescribeProjectError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeProjectError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeProjectError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeProjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeProjectError::InternalFailure(ref cause) => write!(f, "{}", cause),
DescribeProjectError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeProjectError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeProjectError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateDeviceFromPlacementError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DisassociateDeviceFromPlacementError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateDeviceFromPlacementError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(
DisassociateDeviceFromPlacementError::InternalFailure(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DisassociateDeviceFromPlacementError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DisassociateDeviceFromPlacementError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
DisassociateDeviceFromPlacementError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateDeviceFromPlacementError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateDeviceFromPlacementError::InternalFailure(ref cause) => {
write!(f, "{}", cause)
}
DisassociateDeviceFromPlacementError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DisassociateDeviceFromPlacementError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DisassociateDeviceFromPlacementError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateDeviceFromPlacementError {}
#[derive(Debug, PartialEq)]
pub enum GetDevicesInPlacementError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl GetDevicesInPlacementError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDevicesInPlacementError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(GetDevicesInPlacementError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(GetDevicesInPlacementError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetDevicesInPlacementError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDevicesInPlacementError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDevicesInPlacementError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetDevicesInPlacementError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetDevicesInPlacementError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDevicesInPlacementError {}
#[derive(Debug, PartialEq)]
pub enum ListPlacementsError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl ListPlacementsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPlacementsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(ListPlacementsError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListPlacementsError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListPlacementsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPlacementsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPlacementsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListPlacementsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListPlacementsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPlacementsError {}
#[derive(Debug, PartialEq)]
pub enum ListProjectsError {
InternalFailure(String),
InvalidRequest(String),
}
impl ListProjectsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListProjectsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(ListProjectsError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListProjectsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListProjectsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListProjectsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListProjectsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListProjectsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(ListTagsForResourceError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(TagResourceError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(TagResourceError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(UntagResourceError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UntagResourceError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdatePlacementError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl UpdatePlacementError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdatePlacementError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(UpdatePlacementError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdatePlacementError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdatePlacementError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdatePlacementError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdatePlacementError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdatePlacementError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdatePlacementError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdatePlacementError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdatePlacementError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdatePlacementError {}
#[derive(Debug, PartialEq)]
pub enum UpdateProjectError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl UpdateProjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateProjectError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(UpdateProjectError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateProjectError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateProjectError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateProjectError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateProjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateProjectError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateProjectError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateProjectError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateProjectError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateProjectError {}
#[async_trait]
pub trait Iot1ClickProjects {
async fn associate_device_with_placement(
&self,
input: AssociateDeviceWithPlacementRequest,
) -> Result<AssociateDeviceWithPlacementResponse, RusotoError<AssociateDeviceWithPlacementError>>;
async fn create_placement(
&self,
input: CreatePlacementRequest,
) -> Result<CreatePlacementResponse, RusotoError<CreatePlacementError>>;
async fn create_project(
&self,
input: CreateProjectRequest,
) -> Result<CreateProjectResponse, RusotoError<CreateProjectError>>;
async fn delete_placement(
&self,
input: DeletePlacementRequest,
) -> Result<DeletePlacementResponse, RusotoError<DeletePlacementError>>;
async fn delete_project(
&self,
input: DeleteProjectRequest,
) -> Result<DeleteProjectResponse, RusotoError<DeleteProjectError>>;
async fn describe_placement(
&self,
input: DescribePlacementRequest,
) -> Result<DescribePlacementResponse, RusotoError<DescribePlacementError>>;
async fn describe_project(
&self,
input: DescribeProjectRequest,
) -> Result<DescribeProjectResponse, RusotoError<DescribeProjectError>>;
async fn disassociate_device_from_placement(
&self,
input: DisassociateDeviceFromPlacementRequest,
) -> Result<
DisassociateDeviceFromPlacementResponse,
RusotoError<DisassociateDeviceFromPlacementError>,
>;
async fn get_devices_in_placement(
&self,
input: GetDevicesInPlacementRequest,
) -> Result<GetDevicesInPlacementResponse, RusotoError<GetDevicesInPlacementError>>;
async fn list_placements(
&self,
input: ListPlacementsRequest,
) -> Result<ListPlacementsResponse, RusotoError<ListPlacementsError>>;
async fn list_projects(
&self,
input: ListProjectsRequest,
) -> Result<ListProjectsResponse, RusotoError<ListProjectsError>>;
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_placement(
&self,
input: UpdatePlacementRequest,
) -> Result<UpdatePlacementResponse, RusotoError<UpdatePlacementError>>;
async fn update_project(
&self,
input: UpdateProjectRequest,
) -> Result<UpdateProjectResponse, RusotoError<UpdateProjectError>>;
}
#[derive(Clone)]
pub struct Iot1ClickProjectsClient {
client: Client,
region: region::Region,
}
impl Iot1ClickProjectsClient {
pub fn new(region: region::Region) -> Iot1ClickProjectsClient {
Iot1ClickProjectsClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> Iot1ClickProjectsClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
Iot1ClickProjectsClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> Iot1ClickProjectsClient {
Iot1ClickProjectsClient { client, region }
}
}
#[async_trait]
impl Iot1ClickProjects for Iot1ClickProjectsClient {
#[allow(unused_mut)]
async fn associate_device_with_placement(
&self,
input: AssociateDeviceWithPlacementRequest,
) -> Result<AssociateDeviceWithPlacementResponse, RusotoError<AssociateDeviceWithPlacementError>>
{
let request_uri = format!(
"/projects/{project_name}/placements/{placement_name}/devices/{device_template_name}",
device_template_name = input.device_template_name,
placement_name = input.placement_name,
project_name = input.project_name
);
let mut request = SignedRequest::new("PUT", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateDeviceWithPlacementResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AssociateDeviceWithPlacementError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_placement(
&self,
input: CreatePlacementRequest,
) -> Result<CreatePlacementResponse, RusotoError<CreatePlacementError>> {
let request_uri = format!(
"/projects/{project_name}/placements",
project_name = input.project_name
);
let mut request = SignedRequest::new("POST", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreatePlacementResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreatePlacementError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_project(
&self,
input: CreateProjectRequest,
) -> Result<CreateProjectResponse, RusotoError<CreateProjectError>> {
let request_uri = "/projects";
let mut request = SignedRequest::new("POST", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateProjectResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateProjectError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_placement(
&self,
input: DeletePlacementRequest,
) -> Result<DeletePlacementResponse, RusotoError<DeletePlacementError>> {
let request_uri = format!(
"/projects/{project_name}/placements/{placement_name}",
placement_name = input.placement_name,
project_name = input.project_name
);
let mut request = SignedRequest::new("DELETE", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
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::<DeletePlacementResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeletePlacementError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_project(
&self,
input: DeleteProjectRequest,
) -> Result<DeleteProjectResponse, RusotoError<DeleteProjectError>> {
let request_uri = format!(
"/projects/{project_name}",
project_name = input.project_name
);
let mut request = SignedRequest::new("DELETE", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
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::<DeleteProjectResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteProjectError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_placement(
&self,
input: DescribePlacementRequest,
) -> Result<DescribePlacementResponse, RusotoError<DescribePlacementError>> {
let request_uri = format!(
"/projects/{project_name}/placements/{placement_name}",
placement_name = input.placement_name,
project_name = input.project_name
);
let mut request = SignedRequest::new("GET", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
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::<DescribePlacementResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribePlacementError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_project(
&self,
input: DescribeProjectRequest,
) -> Result<DescribeProjectResponse, RusotoError<DescribeProjectError>> {
let request_uri = format!(
"/projects/{project_name}",
project_name = input.project_name
);
let mut request = SignedRequest::new("GET", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
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::<DescribeProjectResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeProjectError::from_response(response))
}
}
#[allow(unused_mut)]
async fn disassociate_device_from_placement(
&self,
input: DisassociateDeviceFromPlacementRequest,
) -> Result<
DisassociateDeviceFromPlacementResponse,
RusotoError<DisassociateDeviceFromPlacementError>,
> {
let request_uri = format!(
"/projects/{project_name}/placements/{placement_name}/devices/{device_template_name}",
device_template_name = input.device_template_name,
placement_name = input.placement_name,
project_name = input.project_name
);
let mut request = SignedRequest::new("DELETE", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
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::<DisassociateDeviceFromPlacementResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateDeviceFromPlacementError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn get_devices_in_placement(
&self,
input: GetDevicesInPlacementRequest,
) -> Result<GetDevicesInPlacementResponse, RusotoError<GetDevicesInPlacementError>> {
let request_uri = format!(
"/projects/{project_name}/placements/{placement_name}/devices",
placement_name = input.placement_name,
project_name = input.project_name
);
let mut request = SignedRequest::new("GET", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
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::<GetDevicesInPlacementResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDevicesInPlacementError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_placements(
&self,
input: ListPlacementsRequest,
) -> Result<ListPlacementsResponse, RusotoError<ListPlacementsError>> {
let request_uri = format!(
"/projects/{project_name}/placements",
project_name = input.project_name
);
let mut request = SignedRequest::new("GET", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListPlacementsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListPlacementsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_projects(
&self,
input: ListProjectsRequest,
) -> Result<ListProjectsResponse, RusotoError<ListProjectsError>> {
let request_uri = "/projects";
let mut request = SignedRequest::new("GET", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListProjectsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListProjectsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
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::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<TagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
let mut params = Params::new();
for item in input.tag_keys.iter() {
params.put("tagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UntagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_placement(
&self,
input: UpdatePlacementRequest,
) -> Result<UpdatePlacementResponse, RusotoError<UpdatePlacementError>> {
let request_uri = format!(
"/projects/{project_name}/placements/{placement_name}",
placement_name = input.placement_name,
project_name = input.project_name
);
let mut request = SignedRequest::new("PUT", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdatePlacementResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdatePlacementError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_project(
&self,
input: UpdateProjectRequest,
) -> Result<UpdateProjectResponse, RusotoError<UpdateProjectError>> {
let request_uri = format!(
"/projects/{project_name}",
project_name = input.project_name
);
let mut request = SignedRequest::new("PUT", "iot1click", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.set_endpoint_prefix("projects.iot1click".to_string());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateProjectResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateProjectError::from_response(response))
}
}
}