use std::error::Error;
use std::fmt;
use std::io;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoFuture};
use rusoto_core::credential::{CredentialsError, ProvideAwsCredentials};
use rusoto_core::request::HttpDispatchError;
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::signature::SignedRequest;
use serde_json;
use serde_json::from_slice;
use serde_json::Value as SerdeJsonValue;
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AssociateRoleToGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssociateRoleToGroupResponse {
#[serde(rename = "AssociatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_at: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AssociateServiceRoleToAccountRequest {
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssociateServiceRoleToAccountResponse {
#[serde(rename = "AssociatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_at: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BulkDeployment {
#[serde(rename = "BulkDeploymentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployment_arn: Option<String>,
#[serde(rename = "BulkDeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployment_id: Option<String>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BulkDeploymentMetrics {
#[serde(rename = "InvalidInputRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invalid_input_records: Option<i64>,
#[serde(rename = "RecordsProcessed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub records_processed: Option<i64>,
#[serde(rename = "RetryAttempts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retry_attempts: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BulkDeploymentResult {
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "DeploymentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_arn: Option<String>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "DeploymentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_status: Option<String>,
#[serde(rename = "DeploymentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_type: Option<String>,
#[serde(rename = "ErrorDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_details: Option<Vec<ErrorDetail>>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "GroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConnectivityInfo {
#[serde(rename = "HostAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub host_address: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Metadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<String>,
#[serde(rename = "PortNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_number: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Connector {
#[serde(rename = "ConnectorArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConnectorDefinitionVersion {
#[serde(rename = "Connectors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connectors: Option<Vec<Connector>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Core {
#[serde(rename = "CertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "SyncShadow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sync_shadow: Option<bool>,
#[serde(rename = "ThingArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub thing_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CoreDefinitionVersion {
#[serde(rename = "Cores")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cores: Option<Vec<Core>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateConnectorDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<ConnectorDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateConnectorDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateConnectorDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "ConnectorDefinitionId")]
pub connector_definition_id: String,
#[serde(rename = "Connectors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connectors: Option<Vec<Connector>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateConnectorDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateCoreDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<CoreDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateCoreDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateCoreDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "CoreDefinitionId")]
pub core_definition_id: String,
#[serde(rename = "Cores")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cores: Option<Vec<Core>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateCoreDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateDeploymentRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "DeploymentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_type: Option<String>,
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "GroupVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_version_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateDeploymentResponse {
#[serde(rename = "DeploymentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_arn: Option<String>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateDeviceDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<DeviceDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateDeviceDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateDeviceDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "DeviceDefinitionId")]
pub device_definition_id: String,
#[serde(rename = "Devices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub devices: Option<Vec<Device>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateDeviceDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateFunctionDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<FunctionDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateFunctionDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateFunctionDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "DefaultConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_config: Option<FunctionDefaultConfig>,
#[serde(rename = "FunctionDefinitionId")]
pub function_definition_id: String,
#[serde(rename = "Functions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub functions: Option<Vec<Function>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateFunctionDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateGroupCertificateAuthorityRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateGroupCertificateAuthorityResponse {
#[serde(rename = "GroupCertificateAuthorityArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_certificate_authority_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateGroupRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<GroupVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateGroupResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateGroupVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "ConnectorDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_definition_version_arn: Option<String>,
#[serde(rename = "CoreDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub core_definition_version_arn: Option<String>,
#[serde(rename = "DeviceDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_definition_version_arn: Option<String>,
#[serde(rename = "FunctionDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_definition_version_arn: Option<String>,
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "LoggerDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logger_definition_version_arn: Option<String>,
#[serde(rename = "ResourceDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_definition_version_arn: Option<String>,
#[serde(rename = "SubscriptionDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_definition_version_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateGroupVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateLoggerDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<LoggerDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateLoggerDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateLoggerDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "LoggerDefinitionId")]
pub logger_definition_id: String,
#[serde(rename = "Loggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub loggers: Option<Vec<Logger>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateLoggerDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateResourceDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<ResourceDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateResourceDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateResourceDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "ResourceDefinitionId")]
pub resource_definition_id: String,
#[serde(rename = "Resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<Vec<Resource>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateResourceDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateSoftwareUpdateJobRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "S3UrlSignerRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_url_signer_role: Option<String>,
#[serde(rename = "SoftwareToUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub software_to_update: Option<String>,
#[serde(rename = "UpdateAgentLogLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_agent_log_level: Option<String>,
#[serde(rename = "UpdateTargets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_targets: Option<Vec<String>>,
#[serde(rename = "UpdateTargetsArchitecture")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_targets_architecture: Option<String>,
#[serde(rename = "UpdateTargetsOperatingSystem")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_targets_operating_system: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateSoftwareUpdateJobResponse {
#[serde(rename = "IotJobArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iot_job_arn: Option<String>,
#[serde(rename = "IotJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iot_job_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateSubscriptionDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<SubscriptionDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateSubscriptionDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateSubscriptionDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "SubscriptionDefinitionId")]
pub subscription_definition_id: String,
#[serde(rename = "Subscriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscriptions: Option<Vec<Subscription>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateSubscriptionDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DefinitionInformation {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteConnectorDefinitionRequest {
#[serde(rename = "ConnectorDefinitionId")]
pub connector_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteConnectorDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteCoreDefinitionRequest {
#[serde(rename = "CoreDefinitionId")]
pub core_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteCoreDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteDeviceDefinitionRequest {
#[serde(rename = "DeviceDefinitionId")]
pub device_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteDeviceDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteFunctionDefinitionRequest {
#[serde(rename = "FunctionDefinitionId")]
pub function_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteFunctionDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteGroupResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteLoggerDefinitionRequest {
#[serde(rename = "LoggerDefinitionId")]
pub logger_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteLoggerDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteResourceDefinitionRequest {
#[serde(rename = "ResourceDefinitionId")]
pub resource_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteResourceDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteSubscriptionDefinitionRequest {
#[serde(rename = "SubscriptionDefinitionId")]
pub subscription_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteSubscriptionDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Deployment {
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "DeploymentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_arn: Option<String>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "DeploymentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_type: Option<String>,
#[serde(rename = "GroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Device {
#[serde(rename = "CertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "SyncShadow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sync_shadow: Option<bool>,
#[serde(rename = "ThingArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub thing_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DeviceDefinitionVersion {
#[serde(rename = "Devices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub devices: Option<Vec<Device>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DisassociateRoleFromGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DisassociateRoleFromGroupResponse {
#[serde(rename = "DisassociatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disassociated_at: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DisassociateServiceRoleFromAccountRequest {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DisassociateServiceRoleFromAccountResponse {
#[serde(rename = "DisassociatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disassociated_at: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct Empty {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ErrorDetail {
#[serde(rename = "DetailedErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detailed_error_code: Option<String>,
#[serde(rename = "DetailedErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detailed_error_message: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Function {
#[serde(rename = "FunctionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_arn: Option<String>,
#[serde(rename = "FunctionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_configuration: Option<FunctionConfiguration>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FunctionConfiguration {
#[serde(rename = "EncodingType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encoding_type: Option<String>,
#[serde(rename = "Environment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<FunctionConfigurationEnvironment>,
#[serde(rename = "ExecArgs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exec_args: Option<String>,
#[serde(rename = "Executable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub executable: Option<String>,
#[serde(rename = "MemorySize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub memory_size: Option<i64>,
#[serde(rename = "Pinned")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pinned: Option<bool>,
#[serde(rename = "Timeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FunctionConfigurationEnvironment {
#[serde(rename = "AccessSysfs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_sysfs: Option<bool>,
#[serde(rename = "Execution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution: Option<FunctionExecutionConfig>,
#[serde(rename = "ResourceAccessPolicies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_access_policies: Option<Vec<ResourceAccessPolicy>>,
#[serde(rename = "Variables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub variables: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FunctionDefaultConfig {
#[serde(rename = "Execution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution: Option<FunctionDefaultExecutionConfig>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FunctionDefaultExecutionConfig {
#[serde(rename = "IsolationMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub isolation_mode: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FunctionDefinitionVersion {
#[serde(rename = "DefaultConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_config: Option<FunctionDefaultConfig>,
#[serde(rename = "Functions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub functions: Option<Vec<Function>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FunctionExecutionConfig {
#[serde(rename = "IsolationMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub isolation_mode: Option<String>,
#[serde(rename = "RunAs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run_as: Option<FunctionRunAsConfig>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FunctionRunAsConfig {
#[serde(rename = "Gid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gid: Option<i64>,
#[serde(rename = "Uid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uid: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GeneralError {
pub error_details: Option<Vec<ErrorDetail>>,
pub message: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetAssociatedRoleRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetAssociatedRoleResponse {
#[serde(rename = "AssociatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_at: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetBulkDeploymentStatusRequest {
#[serde(rename = "BulkDeploymentId")]
pub bulk_deployment_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetBulkDeploymentStatusResponse {
#[serde(rename = "BulkDeploymentMetrics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployment_metrics: Option<BulkDeploymentMetrics>,
#[serde(rename = "BulkDeploymentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployment_status: Option<String>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "ErrorDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_details: Option<Vec<ErrorDetail>>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetConnectivityInfoRequest {
#[serde(rename = "ThingName")]
pub thing_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetConnectivityInfoResponse {
#[serde(rename = "ConnectivityInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connectivity_info: Option<Vec<ConnectivityInfo>>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetConnectorDefinitionRequest {
#[serde(rename = "ConnectorDefinitionId")]
pub connector_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetConnectorDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetConnectorDefinitionVersionRequest {
#[serde(rename = "ConnectorDefinitionId")]
pub connector_definition_id: String,
#[serde(rename = "ConnectorDefinitionVersionId")]
pub connector_definition_version_id: String,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetConnectorDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<ConnectorDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetCoreDefinitionRequest {
#[serde(rename = "CoreDefinitionId")]
pub core_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetCoreDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetCoreDefinitionVersionRequest {
#[serde(rename = "CoreDefinitionId")]
pub core_definition_id: String,
#[serde(rename = "CoreDefinitionVersionId")]
pub core_definition_version_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetCoreDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<CoreDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetDeploymentStatusRequest {
#[serde(rename = "DeploymentId")]
pub deployment_id: String,
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetDeploymentStatusResponse {
#[serde(rename = "DeploymentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_status: Option<String>,
#[serde(rename = "DeploymentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_type: Option<String>,
#[serde(rename = "ErrorDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_details: Option<Vec<ErrorDetail>>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "UpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetDeviceDefinitionRequest {
#[serde(rename = "DeviceDefinitionId")]
pub device_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetDeviceDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetDeviceDefinitionVersionRequest {
#[serde(rename = "DeviceDefinitionId")]
pub device_definition_id: String,
#[serde(rename = "DeviceDefinitionVersionId")]
pub device_definition_version_id: String,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetDeviceDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<DeviceDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetFunctionDefinitionRequest {
#[serde(rename = "FunctionDefinitionId")]
pub function_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetFunctionDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetFunctionDefinitionVersionRequest {
#[serde(rename = "FunctionDefinitionId")]
pub function_definition_id: String,
#[serde(rename = "FunctionDefinitionVersionId")]
pub function_definition_version_id: String,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetFunctionDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<FunctionDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetGroupCertificateAuthorityRequest {
#[serde(rename = "CertificateAuthorityId")]
pub certificate_authority_id: String,
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetGroupCertificateAuthorityResponse {
#[serde(rename = "GroupCertificateAuthorityArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_certificate_authority_arn: Option<String>,
#[serde(rename = "GroupCertificateAuthorityId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_certificate_authority_id: Option<String>,
#[serde(rename = "PemEncodedCertificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pem_encoded_certificate: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetGroupCertificateConfigurationRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetGroupCertificateConfigurationResponse {
#[serde(rename = "CertificateAuthorityExpiryInMilliseconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_authority_expiry_in_milliseconds: Option<String>,
#[serde(rename = "CertificateExpiryInMilliseconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_expiry_in_milliseconds: Option<String>,
#[serde(rename = "GroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetGroupResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetGroupVersionRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "GroupVersionId")]
pub group_version_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetGroupVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<GroupVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetLoggerDefinitionRequest {
#[serde(rename = "LoggerDefinitionId")]
pub logger_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetLoggerDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetLoggerDefinitionVersionRequest {
#[serde(rename = "LoggerDefinitionId")]
pub logger_definition_id: String,
#[serde(rename = "LoggerDefinitionVersionId")]
pub logger_definition_version_id: String,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetLoggerDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<LoggerDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetResourceDefinitionRequest {
#[serde(rename = "ResourceDefinitionId")]
pub resource_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetResourceDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetResourceDefinitionVersionRequest {
#[serde(rename = "ResourceDefinitionId")]
pub resource_definition_id: String,
#[serde(rename = "ResourceDefinitionVersionId")]
pub resource_definition_version_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetResourceDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<ResourceDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetServiceRoleForAccountRequest {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetServiceRoleForAccountResponse {
#[serde(rename = "AssociatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_at: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetSubscriptionDefinitionRequest {
#[serde(rename = "SubscriptionDefinitionId")]
pub subscription_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetSubscriptionDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetSubscriptionDefinitionVersionRequest {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SubscriptionDefinitionId")]
pub subscription_definition_id: String,
#[serde(rename = "SubscriptionDefinitionVersionId")]
pub subscription_definition_version_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetSubscriptionDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<SubscriptionDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GroupCertificateAuthorityProperties {
#[serde(rename = "GroupCertificateAuthorityArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_certificate_authority_arn: Option<String>,
#[serde(rename = "GroupCertificateAuthorityId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_certificate_authority_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct GroupCertificateConfiguration {
pub certificate_authority_expiry_in_milliseconds: Option<String>,
pub certificate_expiry_in_milliseconds: Option<String>,
pub group_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GroupInformation {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GroupOwnerSetting {
#[serde(rename = "AutoAddGroupOwner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_add_group_owner: Option<bool>,
#[serde(rename = "GroupOwner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_owner: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GroupVersion {
#[serde(rename = "ConnectorDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_definition_version_arn: Option<String>,
#[serde(rename = "CoreDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub core_definition_version_arn: Option<String>,
#[serde(rename = "DeviceDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_definition_version_arn: Option<String>,
#[serde(rename = "FunctionDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_definition_version_arn: Option<String>,
#[serde(rename = "LoggerDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logger_definition_version_arn: Option<String>,
#[serde(rename = "ResourceDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_definition_version_arn: Option<String>,
#[serde(rename = "SubscriptionDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_definition_version_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListBulkDeploymentDetailedReportsRequest {
#[serde(rename = "BulkDeploymentId")]
pub bulk_deployment_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListBulkDeploymentDetailedReportsResponse {
#[serde(rename = "Deployments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployments: Option<Vec<BulkDeploymentResult>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListBulkDeploymentsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListBulkDeploymentsResponse {
#[serde(rename = "BulkDeployments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployments: Option<Vec<BulkDeployment>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListConnectorDefinitionVersionsRequest {
#[serde(rename = "ConnectorDefinitionId")]
pub connector_definition_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListConnectorDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListConnectorDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListConnectorDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListCoreDefinitionVersionsRequest {
#[serde(rename = "CoreDefinitionId")]
pub core_definition_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListCoreDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListCoreDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListCoreDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListDefinitionsResponse {
pub definitions: Option<Vec<DefinitionInformation>>,
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListDeploymentsRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListDeploymentsResponse {
#[serde(rename = "Deployments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployments: Option<Vec<Deployment>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListDeviceDefinitionVersionsRequest {
#[serde(rename = "DeviceDefinitionId")]
pub device_definition_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListDeviceDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListDeviceDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListDeviceDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListFunctionDefinitionVersionsRequest {
#[serde(rename = "FunctionDefinitionId")]
pub function_definition_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListFunctionDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListFunctionDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListFunctionDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListGroupCertificateAuthoritiesRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListGroupCertificateAuthoritiesResponse {
#[serde(rename = "GroupCertificateAuthorities")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_certificate_authorities: Option<Vec<GroupCertificateAuthorityProperties>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListGroupVersionsRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListGroupVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListGroupsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListGroupsResponse {
#[serde(rename = "Groups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub groups: Option<Vec<GroupInformation>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListLoggerDefinitionVersionsRequest {
#[serde(rename = "LoggerDefinitionId")]
pub logger_definition_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListLoggerDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListLoggerDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListLoggerDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListResourceDefinitionVersionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceDefinitionId")]
pub resource_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListResourceDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListResourceDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListResourceDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListSubscriptionDefinitionVersionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SubscriptionDefinitionId")]
pub subscription_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListSubscriptionDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListSubscriptionDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListSubscriptionDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct ListVersionsResponse {
pub next_token: Option<String>,
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LocalDeviceResourceData {
#[serde(rename = "GroupOwnerSetting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_owner_setting: Option<GroupOwnerSetting>,
#[serde(rename = "SourcePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_path: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LocalVolumeResourceData {
#[serde(rename = "DestinationPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_path: Option<String>,
#[serde(rename = "GroupOwnerSetting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_owner_setting: Option<GroupOwnerSetting>,
#[serde(rename = "SourcePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_path: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Logger {
#[serde(rename = "Component")]
#[serde(skip_serializing_if = "Option::is_none")]
pub component: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Level")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level: Option<String>,
#[serde(rename = "Space")]
#[serde(skip_serializing_if = "Option::is_none")]
pub space: Option<i64>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LoggerDefinitionVersion {
#[serde(rename = "Loggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub loggers: Option<Vec<Logger>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ResetDeploymentsRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "Force")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force: Option<bool>,
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ResetDeploymentsResponse {
#[serde(rename = "DeploymentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_arn: Option<String>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Resource {
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ResourceDataContainer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_data_container: Option<ResourceDataContainer>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ResourceAccessPolicy {
#[serde(rename = "Permission")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permission: Option<String>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ResourceDataContainer {
#[serde(rename = "LocalDeviceResourceData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub local_device_resource_data: Option<LocalDeviceResourceData>,
#[serde(rename = "LocalVolumeResourceData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub local_volume_resource_data: Option<LocalVolumeResourceData>,
#[serde(rename = "S3MachineLearningModelResourceData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_machine_learning_model_resource_data: Option<S3MachineLearningModelResourceData>,
#[serde(rename = "SageMakerMachineLearningModelResourceData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sage_maker_machine_learning_model_resource_data:
Option<SageMakerMachineLearningModelResourceData>,
#[serde(rename = "SecretsManagerSecretResourceData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secrets_manager_secret_resource_data: Option<SecretsManagerSecretResourceData>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ResourceDefinitionVersion {
#[serde(rename = "Resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<Vec<Resource>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct S3MachineLearningModelResourceData {
#[serde(rename = "DestinationPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_path: Option<String>,
#[serde(rename = "S3Uri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_uri: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SageMakerMachineLearningModelResourceData {
#[serde(rename = "DestinationPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_path: Option<String>,
#[serde(rename = "SageMakerJobArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sage_maker_job_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SecretsManagerSecretResourceData {
#[serde(rename = "ARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "AdditionalStagingLabelsToDownload")]
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_staging_labels_to_download: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartBulkDeploymentRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "ExecutionRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution_role_arn: Option<String>,
#[serde(rename = "InputFileUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_file_uri: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StartBulkDeploymentResponse {
#[serde(rename = "BulkDeploymentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployment_arn: Option<String>,
#[serde(rename = "BulkDeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployment_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StopBulkDeploymentRequest {
#[serde(rename = "BulkDeploymentId")]
pub bulk_deployment_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StopBulkDeploymentResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Subscription {
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Source")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
#[serde(rename = "Subject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subject: Option<String>,
#[serde(rename = "Target")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SubscriptionDefinitionVersion {
#[serde(rename = "Subscriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscriptions: Option<Vec<Subscription>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateConnectivityInfoRequest {
#[serde(rename = "ConnectivityInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connectivity_info: Option<Vec<ConnectivityInfo>>,
#[serde(rename = "ThingName")]
pub thing_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateConnectivityInfoResponse {
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateConnectorDefinitionRequest {
#[serde(rename = "ConnectorDefinitionId")]
pub connector_definition_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateConnectorDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateCoreDefinitionRequest {
#[serde(rename = "CoreDefinitionId")]
pub core_definition_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateCoreDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateDeviceDefinitionRequest {
#[serde(rename = "DeviceDefinitionId")]
pub device_definition_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateDeviceDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateFunctionDefinitionRequest {
#[serde(rename = "FunctionDefinitionId")]
pub function_definition_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateFunctionDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateGroupCertificateConfigurationRequest {
#[serde(rename = "CertificateExpiryInMilliseconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_expiry_in_milliseconds: Option<String>,
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateGroupCertificateConfigurationResponse {
#[serde(rename = "CertificateAuthorityExpiryInMilliseconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_authority_expiry_in_milliseconds: Option<String>,
#[serde(rename = "CertificateExpiryInMilliseconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_expiry_in_milliseconds: Option<String>,
#[serde(rename = "GroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateGroupResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateLoggerDefinitionRequest {
#[serde(rename = "LoggerDefinitionId")]
pub logger_definition_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateLoggerDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateResourceDefinitionRequest {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ResourceDefinitionId")]
pub resource_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateResourceDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateSubscriptionDefinitionRequest {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SubscriptionDefinitionId")]
pub subscription_definition_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateSubscriptionDefinitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct VersionInformation {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AssociateRoleToGroupError {
BadRequest(String),
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AssociateRoleToGroupError {
pub fn from_response(res: BufferedHttpResponse) -> AssociateRoleToGroupError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return AssociateRoleToGroupError::BadRequest(String::from(error_message));
}
"InternalServerErrorException" => {
return AssociateRoleToGroupError::InternalServerError(String::from(
error_message,
));
}
"ValidationException" => {
return AssociateRoleToGroupError::Validation(error_message.to_string());
}
_ => {}
}
}
return AssociateRoleToGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AssociateRoleToGroupError {
fn from(err: serde_json::error::Error) -> AssociateRoleToGroupError {
AssociateRoleToGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AssociateRoleToGroupError {
fn from(err: CredentialsError) -> AssociateRoleToGroupError {
AssociateRoleToGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for AssociateRoleToGroupError {
fn from(err: HttpDispatchError) -> AssociateRoleToGroupError {
AssociateRoleToGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for AssociateRoleToGroupError {
fn from(err: io::Error) -> AssociateRoleToGroupError {
AssociateRoleToGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AssociateRoleToGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateRoleToGroupError {
fn description(&self) -> &str {
match *self {
AssociateRoleToGroupError::BadRequest(ref cause) => cause,
AssociateRoleToGroupError::InternalServerError(ref cause) => cause,
AssociateRoleToGroupError::Validation(ref cause) => cause,
AssociateRoleToGroupError::Credentials(ref err) => err.description(),
AssociateRoleToGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AssociateRoleToGroupError::ParseError(ref cause) => cause,
AssociateRoleToGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AssociateServiceRoleToAccountError {
BadRequest(String),
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AssociateServiceRoleToAccountError {
pub fn from_response(res: BufferedHttpResponse) -> AssociateServiceRoleToAccountError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return AssociateServiceRoleToAccountError::BadRequest(String::from(
error_message,
));
}
"InternalServerErrorException" => {
return AssociateServiceRoleToAccountError::InternalServerError(String::from(
error_message,
));
}
"ValidationException" => {
return AssociateServiceRoleToAccountError::Validation(error_message.to_string());
}
_ => {}
}
}
return AssociateServiceRoleToAccountError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AssociateServiceRoleToAccountError {
fn from(err: serde_json::error::Error) -> AssociateServiceRoleToAccountError {
AssociateServiceRoleToAccountError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AssociateServiceRoleToAccountError {
fn from(err: CredentialsError) -> AssociateServiceRoleToAccountError {
AssociateServiceRoleToAccountError::Credentials(err)
}
}
impl From<HttpDispatchError> for AssociateServiceRoleToAccountError {
fn from(err: HttpDispatchError) -> AssociateServiceRoleToAccountError {
AssociateServiceRoleToAccountError::HttpDispatch(err)
}
}
impl From<io::Error> for AssociateServiceRoleToAccountError {
fn from(err: io::Error) -> AssociateServiceRoleToAccountError {
AssociateServiceRoleToAccountError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AssociateServiceRoleToAccountError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateServiceRoleToAccountError {
fn description(&self) -> &str {
match *self {
AssociateServiceRoleToAccountError::BadRequest(ref cause) => cause,
AssociateServiceRoleToAccountError::InternalServerError(ref cause) => cause,
AssociateServiceRoleToAccountError::Validation(ref cause) => cause,
AssociateServiceRoleToAccountError::Credentials(ref err) => err.description(),
AssociateServiceRoleToAccountError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AssociateServiceRoleToAccountError::ParseError(ref cause) => cause,
AssociateServiceRoleToAccountError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateConnectorDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateConnectorDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateConnectorDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateConnectorDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return CreateConnectorDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateConnectorDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateConnectorDefinitionError {
fn from(err: serde_json::error::Error) -> CreateConnectorDefinitionError {
CreateConnectorDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateConnectorDefinitionError {
fn from(err: CredentialsError) -> CreateConnectorDefinitionError {
CreateConnectorDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateConnectorDefinitionError {
fn from(err: HttpDispatchError) -> CreateConnectorDefinitionError {
CreateConnectorDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateConnectorDefinitionError {
fn from(err: io::Error) -> CreateConnectorDefinitionError {
CreateConnectorDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateConnectorDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateConnectorDefinitionError {
fn description(&self) -> &str {
match *self {
CreateConnectorDefinitionError::BadRequest(ref cause) => cause,
CreateConnectorDefinitionError::Validation(ref cause) => cause,
CreateConnectorDefinitionError::Credentials(ref err) => err.description(),
CreateConnectorDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateConnectorDefinitionError::ParseError(ref cause) => cause,
CreateConnectorDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateConnectorDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateConnectorDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateConnectorDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateConnectorDefinitionVersionError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return CreateConnectorDefinitionVersionError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return CreateConnectorDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateConnectorDefinitionVersionError {
fn from(err: serde_json::error::Error) -> CreateConnectorDefinitionVersionError {
CreateConnectorDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateConnectorDefinitionVersionError {
fn from(err: CredentialsError) -> CreateConnectorDefinitionVersionError {
CreateConnectorDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateConnectorDefinitionVersionError {
fn from(err: HttpDispatchError) -> CreateConnectorDefinitionVersionError {
CreateConnectorDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateConnectorDefinitionVersionError {
fn from(err: io::Error) -> CreateConnectorDefinitionVersionError {
CreateConnectorDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateConnectorDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateConnectorDefinitionVersionError {
fn description(&self) -> &str {
match *self {
CreateConnectorDefinitionVersionError::BadRequest(ref cause) => cause,
CreateConnectorDefinitionVersionError::Validation(ref cause) => cause,
CreateConnectorDefinitionVersionError::Credentials(ref err) => err.description(),
CreateConnectorDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateConnectorDefinitionVersionError::ParseError(ref cause) => cause,
CreateConnectorDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateCoreDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateCoreDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateCoreDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateCoreDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return CreateCoreDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateCoreDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateCoreDefinitionError {
fn from(err: serde_json::error::Error) -> CreateCoreDefinitionError {
CreateCoreDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateCoreDefinitionError {
fn from(err: CredentialsError) -> CreateCoreDefinitionError {
CreateCoreDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateCoreDefinitionError {
fn from(err: HttpDispatchError) -> CreateCoreDefinitionError {
CreateCoreDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateCoreDefinitionError {
fn from(err: io::Error) -> CreateCoreDefinitionError {
CreateCoreDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateCoreDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateCoreDefinitionError {
fn description(&self) -> &str {
match *self {
CreateCoreDefinitionError::BadRequest(ref cause) => cause,
CreateCoreDefinitionError::Validation(ref cause) => cause,
CreateCoreDefinitionError::Credentials(ref err) => err.description(),
CreateCoreDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateCoreDefinitionError::ParseError(ref cause) => cause,
CreateCoreDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateCoreDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateCoreDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateCoreDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateCoreDefinitionVersionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return CreateCoreDefinitionVersionError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateCoreDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateCoreDefinitionVersionError {
fn from(err: serde_json::error::Error) -> CreateCoreDefinitionVersionError {
CreateCoreDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateCoreDefinitionVersionError {
fn from(err: CredentialsError) -> CreateCoreDefinitionVersionError {
CreateCoreDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateCoreDefinitionVersionError {
fn from(err: HttpDispatchError) -> CreateCoreDefinitionVersionError {
CreateCoreDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateCoreDefinitionVersionError {
fn from(err: io::Error) -> CreateCoreDefinitionVersionError {
CreateCoreDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateCoreDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateCoreDefinitionVersionError {
fn description(&self) -> &str {
match *self {
CreateCoreDefinitionVersionError::BadRequest(ref cause) => cause,
CreateCoreDefinitionVersionError::Validation(ref cause) => cause,
CreateCoreDefinitionVersionError::Credentials(ref err) => err.description(),
CreateCoreDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateCoreDefinitionVersionError::ParseError(ref cause) => cause,
CreateCoreDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDeploymentError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDeploymentError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateDeploymentError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return CreateDeploymentError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateDeploymentError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateDeploymentError {
fn from(err: serde_json::error::Error) -> CreateDeploymentError {
CreateDeploymentError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateDeploymentError {
fn from(err: CredentialsError) -> CreateDeploymentError {
CreateDeploymentError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDeploymentError {
fn from(err: HttpDispatchError) -> CreateDeploymentError {
CreateDeploymentError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDeploymentError {
fn from(err: io::Error) -> CreateDeploymentError {
CreateDeploymentError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDeploymentError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDeploymentError {
fn description(&self) -> &str {
match *self {
CreateDeploymentError::BadRequest(ref cause) => cause,
CreateDeploymentError::Validation(ref cause) => cause,
CreateDeploymentError::Credentials(ref err) => err.description(),
CreateDeploymentError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateDeploymentError::ParseError(ref cause) => cause,
CreateDeploymentError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDeviceDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDeviceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDeviceDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateDeviceDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return CreateDeviceDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateDeviceDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateDeviceDefinitionError {
fn from(err: serde_json::error::Error) -> CreateDeviceDefinitionError {
CreateDeviceDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateDeviceDefinitionError {
fn from(err: CredentialsError) -> CreateDeviceDefinitionError {
CreateDeviceDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDeviceDefinitionError {
fn from(err: HttpDispatchError) -> CreateDeviceDefinitionError {
CreateDeviceDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDeviceDefinitionError {
fn from(err: io::Error) -> CreateDeviceDefinitionError {
CreateDeviceDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDeviceDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDeviceDefinitionError {
fn description(&self) -> &str {
match *self {
CreateDeviceDefinitionError::BadRequest(ref cause) => cause,
CreateDeviceDefinitionError::Validation(ref cause) => cause,
CreateDeviceDefinitionError::Credentials(ref err) => err.description(),
CreateDeviceDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateDeviceDefinitionError::ParseError(ref cause) => cause,
CreateDeviceDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDeviceDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDeviceDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDeviceDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateDeviceDefinitionVersionError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return CreateDeviceDefinitionVersionError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateDeviceDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateDeviceDefinitionVersionError {
fn from(err: serde_json::error::Error) -> CreateDeviceDefinitionVersionError {
CreateDeviceDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateDeviceDefinitionVersionError {
fn from(err: CredentialsError) -> CreateDeviceDefinitionVersionError {
CreateDeviceDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDeviceDefinitionVersionError {
fn from(err: HttpDispatchError) -> CreateDeviceDefinitionVersionError {
CreateDeviceDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDeviceDefinitionVersionError {
fn from(err: io::Error) -> CreateDeviceDefinitionVersionError {
CreateDeviceDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDeviceDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDeviceDefinitionVersionError {
fn description(&self) -> &str {
match *self {
CreateDeviceDefinitionVersionError::BadRequest(ref cause) => cause,
CreateDeviceDefinitionVersionError::Validation(ref cause) => cause,
CreateDeviceDefinitionVersionError::Credentials(ref err) => err.description(),
CreateDeviceDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateDeviceDefinitionVersionError::ParseError(ref cause) => cause,
CreateDeviceDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateFunctionDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateFunctionDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateFunctionDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateFunctionDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return CreateFunctionDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateFunctionDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateFunctionDefinitionError {
fn from(err: serde_json::error::Error) -> CreateFunctionDefinitionError {
CreateFunctionDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateFunctionDefinitionError {
fn from(err: CredentialsError) -> CreateFunctionDefinitionError {
CreateFunctionDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateFunctionDefinitionError {
fn from(err: HttpDispatchError) -> CreateFunctionDefinitionError {
CreateFunctionDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateFunctionDefinitionError {
fn from(err: io::Error) -> CreateFunctionDefinitionError {
CreateFunctionDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateFunctionDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateFunctionDefinitionError {
fn description(&self) -> &str {
match *self {
CreateFunctionDefinitionError::BadRequest(ref cause) => cause,
CreateFunctionDefinitionError::Validation(ref cause) => cause,
CreateFunctionDefinitionError::Credentials(ref err) => err.description(),
CreateFunctionDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateFunctionDefinitionError::ParseError(ref cause) => cause,
CreateFunctionDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateFunctionDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateFunctionDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateFunctionDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateFunctionDefinitionVersionError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return CreateFunctionDefinitionVersionError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return CreateFunctionDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateFunctionDefinitionVersionError {
fn from(err: serde_json::error::Error) -> CreateFunctionDefinitionVersionError {
CreateFunctionDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateFunctionDefinitionVersionError {
fn from(err: CredentialsError) -> CreateFunctionDefinitionVersionError {
CreateFunctionDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateFunctionDefinitionVersionError {
fn from(err: HttpDispatchError) -> CreateFunctionDefinitionVersionError {
CreateFunctionDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateFunctionDefinitionVersionError {
fn from(err: io::Error) -> CreateFunctionDefinitionVersionError {
CreateFunctionDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateFunctionDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateFunctionDefinitionVersionError {
fn description(&self) -> &str {
match *self {
CreateFunctionDefinitionVersionError::BadRequest(ref cause) => cause,
CreateFunctionDefinitionVersionError::Validation(ref cause) => cause,
CreateFunctionDefinitionVersionError::Credentials(ref err) => err.description(),
CreateFunctionDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateFunctionDefinitionVersionError::ParseError(ref cause) => cause,
CreateFunctionDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateGroupError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateGroupError {
pub fn from_response(res: BufferedHttpResponse) -> CreateGroupError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateGroupError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return CreateGroupError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateGroupError {
fn from(err: serde_json::error::Error) -> CreateGroupError {
CreateGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateGroupError {
fn from(err: CredentialsError) -> CreateGroupError {
CreateGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateGroupError {
fn from(err: HttpDispatchError) -> CreateGroupError {
CreateGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateGroupError {
fn from(err: io::Error) -> CreateGroupError {
CreateGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateGroupError {
fn description(&self) -> &str {
match *self {
CreateGroupError::BadRequest(ref cause) => cause,
CreateGroupError::Validation(ref cause) => cause,
CreateGroupError::Credentials(ref err) => err.description(),
CreateGroupError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateGroupError::ParseError(ref cause) => cause,
CreateGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateGroupCertificateAuthorityError {
BadRequest(String),
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateGroupCertificateAuthorityError {
pub fn from_response(res: BufferedHttpResponse) -> CreateGroupCertificateAuthorityError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateGroupCertificateAuthorityError::BadRequest(String::from(
error_message,
));
}
"InternalServerErrorException" => {
return CreateGroupCertificateAuthorityError::InternalServerError(String::from(
error_message,
));
}
"ValidationException" => {
return CreateGroupCertificateAuthorityError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return CreateGroupCertificateAuthorityError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateGroupCertificateAuthorityError {
fn from(err: serde_json::error::Error) -> CreateGroupCertificateAuthorityError {
CreateGroupCertificateAuthorityError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateGroupCertificateAuthorityError {
fn from(err: CredentialsError) -> CreateGroupCertificateAuthorityError {
CreateGroupCertificateAuthorityError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateGroupCertificateAuthorityError {
fn from(err: HttpDispatchError) -> CreateGroupCertificateAuthorityError {
CreateGroupCertificateAuthorityError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateGroupCertificateAuthorityError {
fn from(err: io::Error) -> CreateGroupCertificateAuthorityError {
CreateGroupCertificateAuthorityError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateGroupCertificateAuthorityError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateGroupCertificateAuthorityError {
fn description(&self) -> &str {
match *self {
CreateGroupCertificateAuthorityError::BadRequest(ref cause) => cause,
CreateGroupCertificateAuthorityError::InternalServerError(ref cause) => cause,
CreateGroupCertificateAuthorityError::Validation(ref cause) => cause,
CreateGroupCertificateAuthorityError::Credentials(ref err) => err.description(),
CreateGroupCertificateAuthorityError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateGroupCertificateAuthorityError::ParseError(ref cause) => cause,
CreateGroupCertificateAuthorityError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateGroupVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateGroupVersionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateGroupVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateGroupVersionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return CreateGroupVersionError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateGroupVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateGroupVersionError {
fn from(err: serde_json::error::Error) -> CreateGroupVersionError {
CreateGroupVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateGroupVersionError {
fn from(err: CredentialsError) -> CreateGroupVersionError {
CreateGroupVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateGroupVersionError {
fn from(err: HttpDispatchError) -> CreateGroupVersionError {
CreateGroupVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateGroupVersionError {
fn from(err: io::Error) -> CreateGroupVersionError {
CreateGroupVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateGroupVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateGroupVersionError {
fn description(&self) -> &str {
match *self {
CreateGroupVersionError::BadRequest(ref cause) => cause,
CreateGroupVersionError::Validation(ref cause) => cause,
CreateGroupVersionError::Credentials(ref err) => err.description(),
CreateGroupVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateGroupVersionError::ParseError(ref cause) => cause,
CreateGroupVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateLoggerDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateLoggerDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateLoggerDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateLoggerDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return CreateLoggerDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateLoggerDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateLoggerDefinitionError {
fn from(err: serde_json::error::Error) -> CreateLoggerDefinitionError {
CreateLoggerDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateLoggerDefinitionError {
fn from(err: CredentialsError) -> CreateLoggerDefinitionError {
CreateLoggerDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateLoggerDefinitionError {
fn from(err: HttpDispatchError) -> CreateLoggerDefinitionError {
CreateLoggerDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateLoggerDefinitionError {
fn from(err: io::Error) -> CreateLoggerDefinitionError {
CreateLoggerDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateLoggerDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateLoggerDefinitionError {
fn description(&self) -> &str {
match *self {
CreateLoggerDefinitionError::BadRequest(ref cause) => cause,
CreateLoggerDefinitionError::Validation(ref cause) => cause,
CreateLoggerDefinitionError::Credentials(ref err) => err.description(),
CreateLoggerDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateLoggerDefinitionError::ParseError(ref cause) => cause,
CreateLoggerDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateLoggerDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateLoggerDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateLoggerDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateLoggerDefinitionVersionError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return CreateLoggerDefinitionVersionError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateLoggerDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateLoggerDefinitionVersionError {
fn from(err: serde_json::error::Error) -> CreateLoggerDefinitionVersionError {
CreateLoggerDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateLoggerDefinitionVersionError {
fn from(err: CredentialsError) -> CreateLoggerDefinitionVersionError {
CreateLoggerDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateLoggerDefinitionVersionError {
fn from(err: HttpDispatchError) -> CreateLoggerDefinitionVersionError {
CreateLoggerDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateLoggerDefinitionVersionError {
fn from(err: io::Error) -> CreateLoggerDefinitionVersionError {
CreateLoggerDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateLoggerDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateLoggerDefinitionVersionError {
fn description(&self) -> &str {
match *self {
CreateLoggerDefinitionVersionError::BadRequest(ref cause) => cause,
CreateLoggerDefinitionVersionError::Validation(ref cause) => cause,
CreateLoggerDefinitionVersionError::Credentials(ref err) => err.description(),
CreateLoggerDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateLoggerDefinitionVersionError::ParseError(ref cause) => cause,
CreateLoggerDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateResourceDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateResourceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateResourceDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateResourceDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return CreateResourceDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateResourceDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateResourceDefinitionError {
fn from(err: serde_json::error::Error) -> CreateResourceDefinitionError {
CreateResourceDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateResourceDefinitionError {
fn from(err: CredentialsError) -> CreateResourceDefinitionError {
CreateResourceDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateResourceDefinitionError {
fn from(err: HttpDispatchError) -> CreateResourceDefinitionError {
CreateResourceDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateResourceDefinitionError {
fn from(err: io::Error) -> CreateResourceDefinitionError {
CreateResourceDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateResourceDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateResourceDefinitionError {
fn description(&self) -> &str {
match *self {
CreateResourceDefinitionError::BadRequest(ref cause) => cause,
CreateResourceDefinitionError::Validation(ref cause) => cause,
CreateResourceDefinitionError::Credentials(ref err) => err.description(),
CreateResourceDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateResourceDefinitionError::ParseError(ref cause) => cause,
CreateResourceDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateResourceDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateResourceDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateResourceDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateResourceDefinitionVersionError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return CreateResourceDefinitionVersionError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return CreateResourceDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateResourceDefinitionVersionError {
fn from(err: serde_json::error::Error) -> CreateResourceDefinitionVersionError {
CreateResourceDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateResourceDefinitionVersionError {
fn from(err: CredentialsError) -> CreateResourceDefinitionVersionError {
CreateResourceDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateResourceDefinitionVersionError {
fn from(err: HttpDispatchError) -> CreateResourceDefinitionVersionError {
CreateResourceDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateResourceDefinitionVersionError {
fn from(err: io::Error) -> CreateResourceDefinitionVersionError {
CreateResourceDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateResourceDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateResourceDefinitionVersionError {
fn description(&self) -> &str {
match *self {
CreateResourceDefinitionVersionError::BadRequest(ref cause) => cause,
CreateResourceDefinitionVersionError::Validation(ref cause) => cause,
CreateResourceDefinitionVersionError::Credentials(ref err) => err.description(),
CreateResourceDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateResourceDefinitionVersionError::ParseError(ref cause) => cause,
CreateResourceDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateSoftwareUpdateJobError {
BadRequest(String),
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateSoftwareUpdateJobError {
pub fn from_response(res: BufferedHttpResponse) -> CreateSoftwareUpdateJobError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateSoftwareUpdateJobError::BadRequest(String::from(error_message));
}
"InternalServerErrorException" => {
return CreateSoftwareUpdateJobError::InternalServerError(String::from(
error_message,
));
}
"ValidationException" => {
return CreateSoftwareUpdateJobError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateSoftwareUpdateJobError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateSoftwareUpdateJobError {
fn from(err: serde_json::error::Error) -> CreateSoftwareUpdateJobError {
CreateSoftwareUpdateJobError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateSoftwareUpdateJobError {
fn from(err: CredentialsError) -> CreateSoftwareUpdateJobError {
CreateSoftwareUpdateJobError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateSoftwareUpdateJobError {
fn from(err: HttpDispatchError) -> CreateSoftwareUpdateJobError {
CreateSoftwareUpdateJobError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateSoftwareUpdateJobError {
fn from(err: io::Error) -> CreateSoftwareUpdateJobError {
CreateSoftwareUpdateJobError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateSoftwareUpdateJobError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateSoftwareUpdateJobError {
fn description(&self) -> &str {
match *self {
CreateSoftwareUpdateJobError::BadRequest(ref cause) => cause,
CreateSoftwareUpdateJobError::InternalServerError(ref cause) => cause,
CreateSoftwareUpdateJobError::Validation(ref cause) => cause,
CreateSoftwareUpdateJobError::Credentials(ref err) => err.description(),
CreateSoftwareUpdateJobError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateSoftwareUpdateJobError::ParseError(ref cause) => cause,
CreateSoftwareUpdateJobError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateSubscriptionDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateSubscriptionDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateSubscriptionDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateSubscriptionDefinitionError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return CreateSubscriptionDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateSubscriptionDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateSubscriptionDefinitionError {
fn from(err: serde_json::error::Error) -> CreateSubscriptionDefinitionError {
CreateSubscriptionDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateSubscriptionDefinitionError {
fn from(err: CredentialsError) -> CreateSubscriptionDefinitionError {
CreateSubscriptionDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateSubscriptionDefinitionError {
fn from(err: HttpDispatchError) -> CreateSubscriptionDefinitionError {
CreateSubscriptionDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateSubscriptionDefinitionError {
fn from(err: io::Error) -> CreateSubscriptionDefinitionError {
CreateSubscriptionDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateSubscriptionDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateSubscriptionDefinitionError {
fn description(&self) -> &str {
match *self {
CreateSubscriptionDefinitionError::BadRequest(ref cause) => cause,
CreateSubscriptionDefinitionError::Validation(ref cause) => cause,
CreateSubscriptionDefinitionError::Credentials(ref err) => err.description(),
CreateSubscriptionDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateSubscriptionDefinitionError::ParseError(ref cause) => cause,
CreateSubscriptionDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateSubscriptionDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateSubscriptionDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateSubscriptionDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return CreateSubscriptionDefinitionVersionError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return CreateSubscriptionDefinitionVersionError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return CreateSubscriptionDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateSubscriptionDefinitionVersionError {
fn from(err: serde_json::error::Error) -> CreateSubscriptionDefinitionVersionError {
CreateSubscriptionDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateSubscriptionDefinitionVersionError {
fn from(err: CredentialsError) -> CreateSubscriptionDefinitionVersionError {
CreateSubscriptionDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateSubscriptionDefinitionVersionError {
fn from(err: HttpDispatchError) -> CreateSubscriptionDefinitionVersionError {
CreateSubscriptionDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateSubscriptionDefinitionVersionError {
fn from(err: io::Error) -> CreateSubscriptionDefinitionVersionError {
CreateSubscriptionDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateSubscriptionDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateSubscriptionDefinitionVersionError {
fn description(&self) -> &str {
match *self {
CreateSubscriptionDefinitionVersionError::BadRequest(ref cause) => cause,
CreateSubscriptionDefinitionVersionError::Validation(ref cause) => cause,
CreateSubscriptionDefinitionVersionError::Credentials(ref err) => err.description(),
CreateSubscriptionDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateSubscriptionDefinitionVersionError::ParseError(ref cause) => cause,
CreateSubscriptionDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteConnectorDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteConnectorDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteConnectorDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DeleteConnectorDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return DeleteConnectorDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteConnectorDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteConnectorDefinitionError {
fn from(err: serde_json::error::Error) -> DeleteConnectorDefinitionError {
DeleteConnectorDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteConnectorDefinitionError {
fn from(err: CredentialsError) -> DeleteConnectorDefinitionError {
DeleteConnectorDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteConnectorDefinitionError {
fn from(err: HttpDispatchError) -> DeleteConnectorDefinitionError {
DeleteConnectorDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteConnectorDefinitionError {
fn from(err: io::Error) -> DeleteConnectorDefinitionError {
DeleteConnectorDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteConnectorDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteConnectorDefinitionError {
fn description(&self) -> &str {
match *self {
DeleteConnectorDefinitionError::BadRequest(ref cause) => cause,
DeleteConnectorDefinitionError::Validation(ref cause) => cause,
DeleteConnectorDefinitionError::Credentials(ref err) => err.description(),
DeleteConnectorDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteConnectorDefinitionError::ParseError(ref cause) => cause,
DeleteConnectorDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteCoreDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteCoreDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteCoreDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DeleteCoreDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return DeleteCoreDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteCoreDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteCoreDefinitionError {
fn from(err: serde_json::error::Error) -> DeleteCoreDefinitionError {
DeleteCoreDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteCoreDefinitionError {
fn from(err: CredentialsError) -> DeleteCoreDefinitionError {
DeleteCoreDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteCoreDefinitionError {
fn from(err: HttpDispatchError) -> DeleteCoreDefinitionError {
DeleteCoreDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteCoreDefinitionError {
fn from(err: io::Error) -> DeleteCoreDefinitionError {
DeleteCoreDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteCoreDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteCoreDefinitionError {
fn description(&self) -> &str {
match *self {
DeleteCoreDefinitionError::BadRequest(ref cause) => cause,
DeleteCoreDefinitionError::Validation(ref cause) => cause,
DeleteCoreDefinitionError::Credentials(ref err) => err.description(),
DeleteCoreDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteCoreDefinitionError::ParseError(ref cause) => cause,
DeleteCoreDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteDeviceDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteDeviceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteDeviceDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DeleteDeviceDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return DeleteDeviceDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteDeviceDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteDeviceDefinitionError {
fn from(err: serde_json::error::Error) -> DeleteDeviceDefinitionError {
DeleteDeviceDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteDeviceDefinitionError {
fn from(err: CredentialsError) -> DeleteDeviceDefinitionError {
DeleteDeviceDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteDeviceDefinitionError {
fn from(err: HttpDispatchError) -> DeleteDeviceDefinitionError {
DeleteDeviceDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteDeviceDefinitionError {
fn from(err: io::Error) -> DeleteDeviceDefinitionError {
DeleteDeviceDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteDeviceDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDeviceDefinitionError {
fn description(&self) -> &str {
match *self {
DeleteDeviceDefinitionError::BadRequest(ref cause) => cause,
DeleteDeviceDefinitionError::Validation(ref cause) => cause,
DeleteDeviceDefinitionError::Credentials(ref err) => err.description(),
DeleteDeviceDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteDeviceDefinitionError::ParseError(ref cause) => cause,
DeleteDeviceDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteFunctionDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteFunctionDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteFunctionDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DeleteFunctionDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return DeleteFunctionDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteFunctionDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteFunctionDefinitionError {
fn from(err: serde_json::error::Error) -> DeleteFunctionDefinitionError {
DeleteFunctionDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteFunctionDefinitionError {
fn from(err: CredentialsError) -> DeleteFunctionDefinitionError {
DeleteFunctionDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteFunctionDefinitionError {
fn from(err: HttpDispatchError) -> DeleteFunctionDefinitionError {
DeleteFunctionDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteFunctionDefinitionError {
fn from(err: io::Error) -> DeleteFunctionDefinitionError {
DeleteFunctionDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteFunctionDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteFunctionDefinitionError {
fn description(&self) -> &str {
match *self {
DeleteFunctionDefinitionError::BadRequest(ref cause) => cause,
DeleteFunctionDefinitionError::Validation(ref cause) => cause,
DeleteFunctionDefinitionError::Credentials(ref err) => err.description(),
DeleteFunctionDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteFunctionDefinitionError::ParseError(ref cause) => cause,
DeleteFunctionDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteGroupError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteGroupError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteGroupError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DeleteGroupError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return DeleteGroupError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteGroupError {
fn from(err: serde_json::error::Error) -> DeleteGroupError {
DeleteGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteGroupError {
fn from(err: CredentialsError) -> DeleteGroupError {
DeleteGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteGroupError {
fn from(err: HttpDispatchError) -> DeleteGroupError {
DeleteGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteGroupError {
fn from(err: io::Error) -> DeleteGroupError {
DeleteGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteGroupError {
fn description(&self) -> &str {
match *self {
DeleteGroupError::BadRequest(ref cause) => cause,
DeleteGroupError::Validation(ref cause) => cause,
DeleteGroupError::Credentials(ref err) => err.description(),
DeleteGroupError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteGroupError::ParseError(ref cause) => cause,
DeleteGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteLoggerDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteLoggerDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteLoggerDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DeleteLoggerDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return DeleteLoggerDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteLoggerDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteLoggerDefinitionError {
fn from(err: serde_json::error::Error) -> DeleteLoggerDefinitionError {
DeleteLoggerDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteLoggerDefinitionError {
fn from(err: CredentialsError) -> DeleteLoggerDefinitionError {
DeleteLoggerDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteLoggerDefinitionError {
fn from(err: HttpDispatchError) -> DeleteLoggerDefinitionError {
DeleteLoggerDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteLoggerDefinitionError {
fn from(err: io::Error) -> DeleteLoggerDefinitionError {
DeleteLoggerDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteLoggerDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteLoggerDefinitionError {
fn description(&self) -> &str {
match *self {
DeleteLoggerDefinitionError::BadRequest(ref cause) => cause,
DeleteLoggerDefinitionError::Validation(ref cause) => cause,
DeleteLoggerDefinitionError::Credentials(ref err) => err.description(),
DeleteLoggerDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteLoggerDefinitionError::ParseError(ref cause) => cause,
DeleteLoggerDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteResourceDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteResourceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteResourceDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DeleteResourceDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return DeleteResourceDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteResourceDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteResourceDefinitionError {
fn from(err: serde_json::error::Error) -> DeleteResourceDefinitionError {
DeleteResourceDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteResourceDefinitionError {
fn from(err: CredentialsError) -> DeleteResourceDefinitionError {
DeleteResourceDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteResourceDefinitionError {
fn from(err: HttpDispatchError) -> DeleteResourceDefinitionError {
DeleteResourceDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteResourceDefinitionError {
fn from(err: io::Error) -> DeleteResourceDefinitionError {
DeleteResourceDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteResourceDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteResourceDefinitionError {
fn description(&self) -> &str {
match *self {
DeleteResourceDefinitionError::BadRequest(ref cause) => cause,
DeleteResourceDefinitionError::Validation(ref cause) => cause,
DeleteResourceDefinitionError::Credentials(ref err) => err.description(),
DeleteResourceDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteResourceDefinitionError::ParseError(ref cause) => cause,
DeleteResourceDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteSubscriptionDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteSubscriptionDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteSubscriptionDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DeleteSubscriptionDefinitionError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return DeleteSubscriptionDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteSubscriptionDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteSubscriptionDefinitionError {
fn from(err: serde_json::error::Error) -> DeleteSubscriptionDefinitionError {
DeleteSubscriptionDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteSubscriptionDefinitionError {
fn from(err: CredentialsError) -> DeleteSubscriptionDefinitionError {
DeleteSubscriptionDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteSubscriptionDefinitionError {
fn from(err: HttpDispatchError) -> DeleteSubscriptionDefinitionError {
DeleteSubscriptionDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteSubscriptionDefinitionError {
fn from(err: io::Error) -> DeleteSubscriptionDefinitionError {
DeleteSubscriptionDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteSubscriptionDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteSubscriptionDefinitionError {
fn description(&self) -> &str {
match *self {
DeleteSubscriptionDefinitionError::BadRequest(ref cause) => cause,
DeleteSubscriptionDefinitionError::Validation(ref cause) => cause,
DeleteSubscriptionDefinitionError::Credentials(ref err) => err.description(),
DeleteSubscriptionDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteSubscriptionDefinitionError::ParseError(ref cause) => cause,
DeleteSubscriptionDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateRoleFromGroupError {
BadRequest(String),
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisassociateRoleFromGroupError {
pub fn from_response(res: BufferedHttpResponse) -> DisassociateRoleFromGroupError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return DisassociateRoleFromGroupError::BadRequest(String::from(error_message));
}
"InternalServerErrorException" => {
return DisassociateRoleFromGroupError::InternalServerError(String::from(
error_message,
));
}
"ValidationException" => {
return DisassociateRoleFromGroupError::Validation(error_message.to_string());
}
_ => {}
}
}
return DisassociateRoleFromGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DisassociateRoleFromGroupError {
fn from(err: serde_json::error::Error) -> DisassociateRoleFromGroupError {
DisassociateRoleFromGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DisassociateRoleFromGroupError {
fn from(err: CredentialsError) -> DisassociateRoleFromGroupError {
DisassociateRoleFromGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisassociateRoleFromGroupError {
fn from(err: HttpDispatchError) -> DisassociateRoleFromGroupError {
DisassociateRoleFromGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for DisassociateRoleFromGroupError {
fn from(err: io::Error) -> DisassociateRoleFromGroupError {
DisassociateRoleFromGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisassociateRoleFromGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateRoleFromGroupError {
fn description(&self) -> &str {
match *self {
DisassociateRoleFromGroupError::BadRequest(ref cause) => cause,
DisassociateRoleFromGroupError::InternalServerError(ref cause) => cause,
DisassociateRoleFromGroupError::Validation(ref cause) => cause,
DisassociateRoleFromGroupError::Credentials(ref err) => err.description(),
DisassociateRoleFromGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DisassociateRoleFromGroupError::ParseError(ref cause) => cause,
DisassociateRoleFromGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateServiceRoleFromAccountError {
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisassociateServiceRoleFromAccountError {
pub fn from_response(res: BufferedHttpResponse) -> DisassociateServiceRoleFromAccountError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"InternalServerErrorException" => {
return DisassociateServiceRoleFromAccountError::InternalServerError(
String::from(error_message),
);
}
"ValidationException" => {
return DisassociateServiceRoleFromAccountError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return DisassociateServiceRoleFromAccountError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DisassociateServiceRoleFromAccountError {
fn from(err: serde_json::error::Error) -> DisassociateServiceRoleFromAccountError {
DisassociateServiceRoleFromAccountError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DisassociateServiceRoleFromAccountError {
fn from(err: CredentialsError) -> DisassociateServiceRoleFromAccountError {
DisassociateServiceRoleFromAccountError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisassociateServiceRoleFromAccountError {
fn from(err: HttpDispatchError) -> DisassociateServiceRoleFromAccountError {
DisassociateServiceRoleFromAccountError::HttpDispatch(err)
}
}
impl From<io::Error> for DisassociateServiceRoleFromAccountError {
fn from(err: io::Error) -> DisassociateServiceRoleFromAccountError {
DisassociateServiceRoleFromAccountError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisassociateServiceRoleFromAccountError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateServiceRoleFromAccountError {
fn description(&self) -> &str {
match *self {
DisassociateServiceRoleFromAccountError::InternalServerError(ref cause) => cause,
DisassociateServiceRoleFromAccountError::Validation(ref cause) => cause,
DisassociateServiceRoleFromAccountError::Credentials(ref err) => err.description(),
DisassociateServiceRoleFromAccountError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DisassociateServiceRoleFromAccountError::ParseError(ref cause) => cause,
DisassociateServiceRoleFromAccountError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetAssociatedRoleError {
BadRequest(String),
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetAssociatedRoleError {
pub fn from_response(res: BufferedHttpResponse) -> GetAssociatedRoleError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetAssociatedRoleError::BadRequest(String::from(error_message));
}
"InternalServerErrorException" => {
return GetAssociatedRoleError::InternalServerError(String::from(error_message));
}
"ValidationException" => {
return GetAssociatedRoleError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetAssociatedRoleError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetAssociatedRoleError {
fn from(err: serde_json::error::Error) -> GetAssociatedRoleError {
GetAssociatedRoleError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetAssociatedRoleError {
fn from(err: CredentialsError) -> GetAssociatedRoleError {
GetAssociatedRoleError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetAssociatedRoleError {
fn from(err: HttpDispatchError) -> GetAssociatedRoleError {
GetAssociatedRoleError::HttpDispatch(err)
}
}
impl From<io::Error> for GetAssociatedRoleError {
fn from(err: io::Error) -> GetAssociatedRoleError {
GetAssociatedRoleError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetAssociatedRoleError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetAssociatedRoleError {
fn description(&self) -> &str {
match *self {
GetAssociatedRoleError::BadRequest(ref cause) => cause,
GetAssociatedRoleError::InternalServerError(ref cause) => cause,
GetAssociatedRoleError::Validation(ref cause) => cause,
GetAssociatedRoleError::Credentials(ref err) => err.description(),
GetAssociatedRoleError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetAssociatedRoleError::ParseError(ref cause) => cause,
GetAssociatedRoleError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetBulkDeploymentStatusError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetBulkDeploymentStatusError {
pub fn from_response(res: BufferedHttpResponse) -> GetBulkDeploymentStatusError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetBulkDeploymentStatusError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetBulkDeploymentStatusError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetBulkDeploymentStatusError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetBulkDeploymentStatusError {
fn from(err: serde_json::error::Error) -> GetBulkDeploymentStatusError {
GetBulkDeploymentStatusError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetBulkDeploymentStatusError {
fn from(err: CredentialsError) -> GetBulkDeploymentStatusError {
GetBulkDeploymentStatusError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetBulkDeploymentStatusError {
fn from(err: HttpDispatchError) -> GetBulkDeploymentStatusError {
GetBulkDeploymentStatusError::HttpDispatch(err)
}
}
impl From<io::Error> for GetBulkDeploymentStatusError {
fn from(err: io::Error) -> GetBulkDeploymentStatusError {
GetBulkDeploymentStatusError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetBulkDeploymentStatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetBulkDeploymentStatusError {
fn description(&self) -> &str {
match *self {
GetBulkDeploymentStatusError::BadRequest(ref cause) => cause,
GetBulkDeploymentStatusError::Validation(ref cause) => cause,
GetBulkDeploymentStatusError::Credentials(ref err) => err.description(),
GetBulkDeploymentStatusError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetBulkDeploymentStatusError::ParseError(ref cause) => cause,
GetBulkDeploymentStatusError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetConnectivityInfoError {
BadRequest(String),
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetConnectivityInfoError {
pub fn from_response(res: BufferedHttpResponse) -> GetConnectivityInfoError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetConnectivityInfoError::BadRequest(String::from(error_message));
}
"InternalServerErrorException" => {
return GetConnectivityInfoError::InternalServerError(String::from(
error_message,
));
}
"ValidationException" => {
return GetConnectivityInfoError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetConnectivityInfoError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetConnectivityInfoError {
fn from(err: serde_json::error::Error) -> GetConnectivityInfoError {
GetConnectivityInfoError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetConnectivityInfoError {
fn from(err: CredentialsError) -> GetConnectivityInfoError {
GetConnectivityInfoError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetConnectivityInfoError {
fn from(err: HttpDispatchError) -> GetConnectivityInfoError {
GetConnectivityInfoError::HttpDispatch(err)
}
}
impl From<io::Error> for GetConnectivityInfoError {
fn from(err: io::Error) -> GetConnectivityInfoError {
GetConnectivityInfoError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetConnectivityInfoError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetConnectivityInfoError {
fn description(&self) -> &str {
match *self {
GetConnectivityInfoError::BadRequest(ref cause) => cause,
GetConnectivityInfoError::InternalServerError(ref cause) => cause,
GetConnectivityInfoError::Validation(ref cause) => cause,
GetConnectivityInfoError::Credentials(ref err) => err.description(),
GetConnectivityInfoError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetConnectivityInfoError::ParseError(ref cause) => cause,
GetConnectivityInfoError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetConnectorDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetConnectorDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> GetConnectorDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetConnectorDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetConnectorDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetConnectorDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetConnectorDefinitionError {
fn from(err: serde_json::error::Error) -> GetConnectorDefinitionError {
GetConnectorDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetConnectorDefinitionError {
fn from(err: CredentialsError) -> GetConnectorDefinitionError {
GetConnectorDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetConnectorDefinitionError {
fn from(err: HttpDispatchError) -> GetConnectorDefinitionError {
GetConnectorDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetConnectorDefinitionError {
fn from(err: io::Error) -> GetConnectorDefinitionError {
GetConnectorDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetConnectorDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetConnectorDefinitionError {
fn description(&self) -> &str {
match *self {
GetConnectorDefinitionError::BadRequest(ref cause) => cause,
GetConnectorDefinitionError::Validation(ref cause) => cause,
GetConnectorDefinitionError::Credentials(ref err) => err.description(),
GetConnectorDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetConnectorDefinitionError::ParseError(ref cause) => cause,
GetConnectorDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetConnectorDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetConnectorDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> GetConnectorDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetConnectorDefinitionVersionError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return GetConnectorDefinitionVersionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetConnectorDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetConnectorDefinitionVersionError {
fn from(err: serde_json::error::Error) -> GetConnectorDefinitionVersionError {
GetConnectorDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetConnectorDefinitionVersionError {
fn from(err: CredentialsError) -> GetConnectorDefinitionVersionError {
GetConnectorDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetConnectorDefinitionVersionError {
fn from(err: HttpDispatchError) -> GetConnectorDefinitionVersionError {
GetConnectorDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetConnectorDefinitionVersionError {
fn from(err: io::Error) -> GetConnectorDefinitionVersionError {
GetConnectorDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetConnectorDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetConnectorDefinitionVersionError {
fn description(&self) -> &str {
match *self {
GetConnectorDefinitionVersionError::BadRequest(ref cause) => cause,
GetConnectorDefinitionVersionError::Validation(ref cause) => cause,
GetConnectorDefinitionVersionError::Credentials(ref err) => err.description(),
GetConnectorDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetConnectorDefinitionVersionError::ParseError(ref cause) => cause,
GetConnectorDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetCoreDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetCoreDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> GetCoreDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetCoreDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetCoreDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetCoreDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetCoreDefinitionError {
fn from(err: serde_json::error::Error) -> GetCoreDefinitionError {
GetCoreDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetCoreDefinitionError {
fn from(err: CredentialsError) -> GetCoreDefinitionError {
GetCoreDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetCoreDefinitionError {
fn from(err: HttpDispatchError) -> GetCoreDefinitionError {
GetCoreDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetCoreDefinitionError {
fn from(err: io::Error) -> GetCoreDefinitionError {
GetCoreDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetCoreDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetCoreDefinitionError {
fn description(&self) -> &str {
match *self {
GetCoreDefinitionError::BadRequest(ref cause) => cause,
GetCoreDefinitionError::Validation(ref cause) => cause,
GetCoreDefinitionError::Credentials(ref err) => err.description(),
GetCoreDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetCoreDefinitionError::ParseError(ref cause) => cause,
GetCoreDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetCoreDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetCoreDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> GetCoreDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetCoreDefinitionVersionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetCoreDefinitionVersionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetCoreDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetCoreDefinitionVersionError {
fn from(err: serde_json::error::Error) -> GetCoreDefinitionVersionError {
GetCoreDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetCoreDefinitionVersionError {
fn from(err: CredentialsError) -> GetCoreDefinitionVersionError {
GetCoreDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetCoreDefinitionVersionError {
fn from(err: HttpDispatchError) -> GetCoreDefinitionVersionError {
GetCoreDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetCoreDefinitionVersionError {
fn from(err: io::Error) -> GetCoreDefinitionVersionError {
GetCoreDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetCoreDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetCoreDefinitionVersionError {
fn description(&self) -> &str {
match *self {
GetCoreDefinitionVersionError::BadRequest(ref cause) => cause,
GetCoreDefinitionVersionError::Validation(ref cause) => cause,
GetCoreDefinitionVersionError::Credentials(ref err) => err.description(),
GetCoreDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetCoreDefinitionVersionError::ParseError(ref cause) => cause,
GetCoreDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetDeploymentStatusError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetDeploymentStatusError {
pub fn from_response(res: BufferedHttpResponse) -> GetDeploymentStatusError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetDeploymentStatusError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetDeploymentStatusError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetDeploymentStatusError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetDeploymentStatusError {
fn from(err: serde_json::error::Error) -> GetDeploymentStatusError {
GetDeploymentStatusError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetDeploymentStatusError {
fn from(err: CredentialsError) -> GetDeploymentStatusError {
GetDeploymentStatusError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetDeploymentStatusError {
fn from(err: HttpDispatchError) -> GetDeploymentStatusError {
GetDeploymentStatusError::HttpDispatch(err)
}
}
impl From<io::Error> for GetDeploymentStatusError {
fn from(err: io::Error) -> GetDeploymentStatusError {
GetDeploymentStatusError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetDeploymentStatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetDeploymentStatusError {
fn description(&self) -> &str {
match *self {
GetDeploymentStatusError::BadRequest(ref cause) => cause,
GetDeploymentStatusError::Validation(ref cause) => cause,
GetDeploymentStatusError::Credentials(ref err) => err.description(),
GetDeploymentStatusError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetDeploymentStatusError::ParseError(ref cause) => cause,
GetDeploymentStatusError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetDeviceDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetDeviceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> GetDeviceDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetDeviceDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetDeviceDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetDeviceDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetDeviceDefinitionError {
fn from(err: serde_json::error::Error) -> GetDeviceDefinitionError {
GetDeviceDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetDeviceDefinitionError {
fn from(err: CredentialsError) -> GetDeviceDefinitionError {
GetDeviceDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetDeviceDefinitionError {
fn from(err: HttpDispatchError) -> GetDeviceDefinitionError {
GetDeviceDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetDeviceDefinitionError {
fn from(err: io::Error) -> GetDeviceDefinitionError {
GetDeviceDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetDeviceDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetDeviceDefinitionError {
fn description(&self) -> &str {
match *self {
GetDeviceDefinitionError::BadRequest(ref cause) => cause,
GetDeviceDefinitionError::Validation(ref cause) => cause,
GetDeviceDefinitionError::Credentials(ref err) => err.description(),
GetDeviceDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetDeviceDefinitionError::ParseError(ref cause) => cause,
GetDeviceDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetDeviceDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetDeviceDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> GetDeviceDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetDeviceDefinitionVersionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetDeviceDefinitionVersionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetDeviceDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetDeviceDefinitionVersionError {
fn from(err: serde_json::error::Error) -> GetDeviceDefinitionVersionError {
GetDeviceDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetDeviceDefinitionVersionError {
fn from(err: CredentialsError) -> GetDeviceDefinitionVersionError {
GetDeviceDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetDeviceDefinitionVersionError {
fn from(err: HttpDispatchError) -> GetDeviceDefinitionVersionError {
GetDeviceDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetDeviceDefinitionVersionError {
fn from(err: io::Error) -> GetDeviceDefinitionVersionError {
GetDeviceDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetDeviceDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetDeviceDefinitionVersionError {
fn description(&self) -> &str {
match *self {
GetDeviceDefinitionVersionError::BadRequest(ref cause) => cause,
GetDeviceDefinitionVersionError::Validation(ref cause) => cause,
GetDeviceDefinitionVersionError::Credentials(ref err) => err.description(),
GetDeviceDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetDeviceDefinitionVersionError::ParseError(ref cause) => cause,
GetDeviceDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetFunctionDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetFunctionDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> GetFunctionDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetFunctionDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetFunctionDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetFunctionDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetFunctionDefinitionError {
fn from(err: serde_json::error::Error) -> GetFunctionDefinitionError {
GetFunctionDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetFunctionDefinitionError {
fn from(err: CredentialsError) -> GetFunctionDefinitionError {
GetFunctionDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetFunctionDefinitionError {
fn from(err: HttpDispatchError) -> GetFunctionDefinitionError {
GetFunctionDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetFunctionDefinitionError {
fn from(err: io::Error) -> GetFunctionDefinitionError {
GetFunctionDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetFunctionDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetFunctionDefinitionError {
fn description(&self) -> &str {
match *self {
GetFunctionDefinitionError::BadRequest(ref cause) => cause,
GetFunctionDefinitionError::Validation(ref cause) => cause,
GetFunctionDefinitionError::Credentials(ref err) => err.description(),
GetFunctionDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetFunctionDefinitionError::ParseError(ref cause) => cause,
GetFunctionDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetFunctionDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetFunctionDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> GetFunctionDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetFunctionDefinitionVersionError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return GetFunctionDefinitionVersionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetFunctionDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetFunctionDefinitionVersionError {
fn from(err: serde_json::error::Error) -> GetFunctionDefinitionVersionError {
GetFunctionDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetFunctionDefinitionVersionError {
fn from(err: CredentialsError) -> GetFunctionDefinitionVersionError {
GetFunctionDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetFunctionDefinitionVersionError {
fn from(err: HttpDispatchError) -> GetFunctionDefinitionVersionError {
GetFunctionDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetFunctionDefinitionVersionError {
fn from(err: io::Error) -> GetFunctionDefinitionVersionError {
GetFunctionDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetFunctionDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetFunctionDefinitionVersionError {
fn description(&self) -> &str {
match *self {
GetFunctionDefinitionVersionError::BadRequest(ref cause) => cause,
GetFunctionDefinitionVersionError::Validation(ref cause) => cause,
GetFunctionDefinitionVersionError::Credentials(ref err) => err.description(),
GetFunctionDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetFunctionDefinitionVersionError::ParseError(ref cause) => cause,
GetFunctionDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetGroupError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> GetGroupError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetGroupError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetGroupError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetGroupError {
fn from(err: serde_json::error::Error) -> GetGroupError {
GetGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetGroupError {
fn from(err: CredentialsError) -> GetGroupError {
GetGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetGroupError {
fn from(err: HttpDispatchError) -> GetGroupError {
GetGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for GetGroupError {
fn from(err: io::Error) -> GetGroupError {
GetGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetGroupError {
fn description(&self) -> &str {
match *self {
GetGroupError::BadRequest(ref cause) => cause,
GetGroupError::Validation(ref cause) => cause,
GetGroupError::Credentials(ref err) => err.description(),
GetGroupError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetGroupError::ParseError(ref cause) => cause,
GetGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetGroupCertificateAuthorityError {
BadRequest(String),
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetGroupCertificateAuthorityError {
pub fn from_response(res: BufferedHttpResponse) -> GetGroupCertificateAuthorityError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetGroupCertificateAuthorityError::BadRequest(String::from(
error_message,
));
}
"InternalServerErrorException" => {
return GetGroupCertificateAuthorityError::InternalServerError(String::from(
error_message,
));
}
"ValidationException" => {
return GetGroupCertificateAuthorityError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetGroupCertificateAuthorityError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetGroupCertificateAuthorityError {
fn from(err: serde_json::error::Error) -> GetGroupCertificateAuthorityError {
GetGroupCertificateAuthorityError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetGroupCertificateAuthorityError {
fn from(err: CredentialsError) -> GetGroupCertificateAuthorityError {
GetGroupCertificateAuthorityError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetGroupCertificateAuthorityError {
fn from(err: HttpDispatchError) -> GetGroupCertificateAuthorityError {
GetGroupCertificateAuthorityError::HttpDispatch(err)
}
}
impl From<io::Error> for GetGroupCertificateAuthorityError {
fn from(err: io::Error) -> GetGroupCertificateAuthorityError {
GetGroupCertificateAuthorityError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetGroupCertificateAuthorityError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetGroupCertificateAuthorityError {
fn description(&self) -> &str {
match *self {
GetGroupCertificateAuthorityError::BadRequest(ref cause) => cause,
GetGroupCertificateAuthorityError::InternalServerError(ref cause) => cause,
GetGroupCertificateAuthorityError::Validation(ref cause) => cause,
GetGroupCertificateAuthorityError::Credentials(ref err) => err.description(),
GetGroupCertificateAuthorityError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetGroupCertificateAuthorityError::ParseError(ref cause) => cause,
GetGroupCertificateAuthorityError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetGroupCertificateConfigurationError {
BadRequest(String),
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetGroupCertificateConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> GetGroupCertificateConfigurationError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetGroupCertificateConfigurationError::BadRequest(String::from(
error_message,
));
}
"InternalServerErrorException" => {
return GetGroupCertificateConfigurationError::InternalServerError(String::from(
error_message,
));
}
"ValidationException" => {
return GetGroupCertificateConfigurationError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return GetGroupCertificateConfigurationError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetGroupCertificateConfigurationError {
fn from(err: serde_json::error::Error) -> GetGroupCertificateConfigurationError {
GetGroupCertificateConfigurationError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetGroupCertificateConfigurationError {
fn from(err: CredentialsError) -> GetGroupCertificateConfigurationError {
GetGroupCertificateConfigurationError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetGroupCertificateConfigurationError {
fn from(err: HttpDispatchError) -> GetGroupCertificateConfigurationError {
GetGroupCertificateConfigurationError::HttpDispatch(err)
}
}
impl From<io::Error> for GetGroupCertificateConfigurationError {
fn from(err: io::Error) -> GetGroupCertificateConfigurationError {
GetGroupCertificateConfigurationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetGroupCertificateConfigurationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetGroupCertificateConfigurationError {
fn description(&self) -> &str {
match *self {
GetGroupCertificateConfigurationError::BadRequest(ref cause) => cause,
GetGroupCertificateConfigurationError::InternalServerError(ref cause) => cause,
GetGroupCertificateConfigurationError::Validation(ref cause) => cause,
GetGroupCertificateConfigurationError::Credentials(ref err) => err.description(),
GetGroupCertificateConfigurationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetGroupCertificateConfigurationError::ParseError(ref cause) => cause,
GetGroupCertificateConfigurationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetGroupVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetGroupVersionError {
pub fn from_response(res: BufferedHttpResponse) -> GetGroupVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetGroupVersionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetGroupVersionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetGroupVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetGroupVersionError {
fn from(err: serde_json::error::Error) -> GetGroupVersionError {
GetGroupVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetGroupVersionError {
fn from(err: CredentialsError) -> GetGroupVersionError {
GetGroupVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetGroupVersionError {
fn from(err: HttpDispatchError) -> GetGroupVersionError {
GetGroupVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetGroupVersionError {
fn from(err: io::Error) -> GetGroupVersionError {
GetGroupVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetGroupVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetGroupVersionError {
fn description(&self) -> &str {
match *self {
GetGroupVersionError::BadRequest(ref cause) => cause,
GetGroupVersionError::Validation(ref cause) => cause,
GetGroupVersionError::Credentials(ref err) => err.description(),
GetGroupVersionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetGroupVersionError::ParseError(ref cause) => cause,
GetGroupVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetLoggerDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetLoggerDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> GetLoggerDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetLoggerDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetLoggerDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetLoggerDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetLoggerDefinitionError {
fn from(err: serde_json::error::Error) -> GetLoggerDefinitionError {
GetLoggerDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetLoggerDefinitionError {
fn from(err: CredentialsError) -> GetLoggerDefinitionError {
GetLoggerDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetLoggerDefinitionError {
fn from(err: HttpDispatchError) -> GetLoggerDefinitionError {
GetLoggerDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetLoggerDefinitionError {
fn from(err: io::Error) -> GetLoggerDefinitionError {
GetLoggerDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetLoggerDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetLoggerDefinitionError {
fn description(&self) -> &str {
match *self {
GetLoggerDefinitionError::BadRequest(ref cause) => cause,
GetLoggerDefinitionError::Validation(ref cause) => cause,
GetLoggerDefinitionError::Credentials(ref err) => err.description(),
GetLoggerDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetLoggerDefinitionError::ParseError(ref cause) => cause,
GetLoggerDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetLoggerDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetLoggerDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> GetLoggerDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetLoggerDefinitionVersionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetLoggerDefinitionVersionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetLoggerDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetLoggerDefinitionVersionError {
fn from(err: serde_json::error::Error) -> GetLoggerDefinitionVersionError {
GetLoggerDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetLoggerDefinitionVersionError {
fn from(err: CredentialsError) -> GetLoggerDefinitionVersionError {
GetLoggerDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetLoggerDefinitionVersionError {
fn from(err: HttpDispatchError) -> GetLoggerDefinitionVersionError {
GetLoggerDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetLoggerDefinitionVersionError {
fn from(err: io::Error) -> GetLoggerDefinitionVersionError {
GetLoggerDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetLoggerDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetLoggerDefinitionVersionError {
fn description(&self) -> &str {
match *self {
GetLoggerDefinitionVersionError::BadRequest(ref cause) => cause,
GetLoggerDefinitionVersionError::Validation(ref cause) => cause,
GetLoggerDefinitionVersionError::Credentials(ref err) => err.description(),
GetLoggerDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetLoggerDefinitionVersionError::ParseError(ref cause) => cause,
GetLoggerDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetResourceDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetResourceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> GetResourceDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetResourceDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetResourceDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetResourceDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetResourceDefinitionError {
fn from(err: serde_json::error::Error) -> GetResourceDefinitionError {
GetResourceDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetResourceDefinitionError {
fn from(err: CredentialsError) -> GetResourceDefinitionError {
GetResourceDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetResourceDefinitionError {
fn from(err: HttpDispatchError) -> GetResourceDefinitionError {
GetResourceDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetResourceDefinitionError {
fn from(err: io::Error) -> GetResourceDefinitionError {
GetResourceDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetResourceDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetResourceDefinitionError {
fn description(&self) -> &str {
match *self {
GetResourceDefinitionError::BadRequest(ref cause) => cause,
GetResourceDefinitionError::Validation(ref cause) => cause,
GetResourceDefinitionError::Credentials(ref err) => err.description(),
GetResourceDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetResourceDefinitionError::ParseError(ref cause) => cause,
GetResourceDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetResourceDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetResourceDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> GetResourceDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetResourceDefinitionVersionError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return GetResourceDefinitionVersionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetResourceDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetResourceDefinitionVersionError {
fn from(err: serde_json::error::Error) -> GetResourceDefinitionVersionError {
GetResourceDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetResourceDefinitionVersionError {
fn from(err: CredentialsError) -> GetResourceDefinitionVersionError {
GetResourceDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetResourceDefinitionVersionError {
fn from(err: HttpDispatchError) -> GetResourceDefinitionVersionError {
GetResourceDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetResourceDefinitionVersionError {
fn from(err: io::Error) -> GetResourceDefinitionVersionError {
GetResourceDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetResourceDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetResourceDefinitionVersionError {
fn description(&self) -> &str {
match *self {
GetResourceDefinitionVersionError::BadRequest(ref cause) => cause,
GetResourceDefinitionVersionError::Validation(ref cause) => cause,
GetResourceDefinitionVersionError::Credentials(ref err) => err.description(),
GetResourceDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetResourceDefinitionVersionError::ParseError(ref cause) => cause,
GetResourceDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetServiceRoleForAccountError {
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetServiceRoleForAccountError {
pub fn from_response(res: BufferedHttpResponse) -> GetServiceRoleForAccountError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"InternalServerErrorException" => {
return GetServiceRoleForAccountError::InternalServerError(String::from(
error_message,
));
}
"ValidationException" => {
return GetServiceRoleForAccountError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetServiceRoleForAccountError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetServiceRoleForAccountError {
fn from(err: serde_json::error::Error) -> GetServiceRoleForAccountError {
GetServiceRoleForAccountError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetServiceRoleForAccountError {
fn from(err: CredentialsError) -> GetServiceRoleForAccountError {
GetServiceRoleForAccountError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetServiceRoleForAccountError {
fn from(err: HttpDispatchError) -> GetServiceRoleForAccountError {
GetServiceRoleForAccountError::HttpDispatch(err)
}
}
impl From<io::Error> for GetServiceRoleForAccountError {
fn from(err: io::Error) -> GetServiceRoleForAccountError {
GetServiceRoleForAccountError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetServiceRoleForAccountError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetServiceRoleForAccountError {
fn description(&self) -> &str {
match *self {
GetServiceRoleForAccountError::InternalServerError(ref cause) => cause,
GetServiceRoleForAccountError::Validation(ref cause) => cause,
GetServiceRoleForAccountError::Credentials(ref err) => err.description(),
GetServiceRoleForAccountError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetServiceRoleForAccountError::ParseError(ref cause) => cause,
GetServiceRoleForAccountError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetSubscriptionDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetSubscriptionDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> GetSubscriptionDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetSubscriptionDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return GetSubscriptionDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetSubscriptionDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetSubscriptionDefinitionError {
fn from(err: serde_json::error::Error) -> GetSubscriptionDefinitionError {
GetSubscriptionDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetSubscriptionDefinitionError {
fn from(err: CredentialsError) -> GetSubscriptionDefinitionError {
GetSubscriptionDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetSubscriptionDefinitionError {
fn from(err: HttpDispatchError) -> GetSubscriptionDefinitionError {
GetSubscriptionDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetSubscriptionDefinitionError {
fn from(err: io::Error) -> GetSubscriptionDefinitionError {
GetSubscriptionDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetSubscriptionDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetSubscriptionDefinitionError {
fn description(&self) -> &str {
match *self {
GetSubscriptionDefinitionError::BadRequest(ref cause) => cause,
GetSubscriptionDefinitionError::Validation(ref cause) => cause,
GetSubscriptionDefinitionError::Credentials(ref err) => err.description(),
GetSubscriptionDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetSubscriptionDefinitionError::ParseError(ref cause) => cause,
GetSubscriptionDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetSubscriptionDefinitionVersionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetSubscriptionDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> GetSubscriptionDefinitionVersionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return GetSubscriptionDefinitionVersionError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return GetSubscriptionDefinitionVersionError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return GetSubscriptionDefinitionVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetSubscriptionDefinitionVersionError {
fn from(err: serde_json::error::Error) -> GetSubscriptionDefinitionVersionError {
GetSubscriptionDefinitionVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetSubscriptionDefinitionVersionError {
fn from(err: CredentialsError) -> GetSubscriptionDefinitionVersionError {
GetSubscriptionDefinitionVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetSubscriptionDefinitionVersionError {
fn from(err: HttpDispatchError) -> GetSubscriptionDefinitionVersionError {
GetSubscriptionDefinitionVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetSubscriptionDefinitionVersionError {
fn from(err: io::Error) -> GetSubscriptionDefinitionVersionError {
GetSubscriptionDefinitionVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetSubscriptionDefinitionVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetSubscriptionDefinitionVersionError {
fn description(&self) -> &str {
match *self {
GetSubscriptionDefinitionVersionError::BadRequest(ref cause) => cause,
GetSubscriptionDefinitionVersionError::Validation(ref cause) => cause,
GetSubscriptionDefinitionVersionError::Credentials(ref err) => err.description(),
GetSubscriptionDefinitionVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetSubscriptionDefinitionVersionError::ParseError(ref cause) => cause,
GetSubscriptionDefinitionVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListBulkDeploymentDetailedReportsError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListBulkDeploymentDetailedReportsError {
pub fn from_response(res: BufferedHttpResponse) -> ListBulkDeploymentDetailedReportsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListBulkDeploymentDetailedReportsError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return ListBulkDeploymentDetailedReportsError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return ListBulkDeploymentDetailedReportsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListBulkDeploymentDetailedReportsError {
fn from(err: serde_json::error::Error) -> ListBulkDeploymentDetailedReportsError {
ListBulkDeploymentDetailedReportsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListBulkDeploymentDetailedReportsError {
fn from(err: CredentialsError) -> ListBulkDeploymentDetailedReportsError {
ListBulkDeploymentDetailedReportsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListBulkDeploymentDetailedReportsError {
fn from(err: HttpDispatchError) -> ListBulkDeploymentDetailedReportsError {
ListBulkDeploymentDetailedReportsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListBulkDeploymentDetailedReportsError {
fn from(err: io::Error) -> ListBulkDeploymentDetailedReportsError {
ListBulkDeploymentDetailedReportsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListBulkDeploymentDetailedReportsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListBulkDeploymentDetailedReportsError {
fn description(&self) -> &str {
match *self {
ListBulkDeploymentDetailedReportsError::BadRequest(ref cause) => cause,
ListBulkDeploymentDetailedReportsError::Validation(ref cause) => cause,
ListBulkDeploymentDetailedReportsError::Credentials(ref err) => err.description(),
ListBulkDeploymentDetailedReportsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListBulkDeploymentDetailedReportsError::ParseError(ref cause) => cause,
ListBulkDeploymentDetailedReportsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListBulkDeploymentsError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListBulkDeploymentsError {
pub fn from_response(res: BufferedHttpResponse) -> ListBulkDeploymentsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListBulkDeploymentsError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return ListBulkDeploymentsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListBulkDeploymentsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListBulkDeploymentsError {
fn from(err: serde_json::error::Error) -> ListBulkDeploymentsError {
ListBulkDeploymentsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListBulkDeploymentsError {
fn from(err: CredentialsError) -> ListBulkDeploymentsError {
ListBulkDeploymentsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListBulkDeploymentsError {
fn from(err: HttpDispatchError) -> ListBulkDeploymentsError {
ListBulkDeploymentsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListBulkDeploymentsError {
fn from(err: io::Error) -> ListBulkDeploymentsError {
ListBulkDeploymentsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListBulkDeploymentsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListBulkDeploymentsError {
fn description(&self) -> &str {
match *self {
ListBulkDeploymentsError::BadRequest(ref cause) => cause,
ListBulkDeploymentsError::Validation(ref cause) => cause,
ListBulkDeploymentsError::Credentials(ref err) => err.description(),
ListBulkDeploymentsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListBulkDeploymentsError::ParseError(ref cause) => cause,
ListBulkDeploymentsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListConnectorDefinitionVersionsError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListConnectorDefinitionVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListConnectorDefinitionVersionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListConnectorDefinitionVersionsError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return ListConnectorDefinitionVersionsError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return ListConnectorDefinitionVersionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListConnectorDefinitionVersionsError {
fn from(err: serde_json::error::Error) -> ListConnectorDefinitionVersionsError {
ListConnectorDefinitionVersionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListConnectorDefinitionVersionsError {
fn from(err: CredentialsError) -> ListConnectorDefinitionVersionsError {
ListConnectorDefinitionVersionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListConnectorDefinitionVersionsError {
fn from(err: HttpDispatchError) -> ListConnectorDefinitionVersionsError {
ListConnectorDefinitionVersionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListConnectorDefinitionVersionsError {
fn from(err: io::Error) -> ListConnectorDefinitionVersionsError {
ListConnectorDefinitionVersionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListConnectorDefinitionVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListConnectorDefinitionVersionsError {
fn description(&self) -> &str {
match *self {
ListConnectorDefinitionVersionsError::BadRequest(ref cause) => cause,
ListConnectorDefinitionVersionsError::Validation(ref cause) => cause,
ListConnectorDefinitionVersionsError::Credentials(ref err) => err.description(),
ListConnectorDefinitionVersionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListConnectorDefinitionVersionsError::ParseError(ref cause) => cause,
ListConnectorDefinitionVersionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListConnectorDefinitionsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListConnectorDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListConnectorDefinitionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ValidationException" => {
return ListConnectorDefinitionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListConnectorDefinitionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListConnectorDefinitionsError {
fn from(err: serde_json::error::Error) -> ListConnectorDefinitionsError {
ListConnectorDefinitionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListConnectorDefinitionsError {
fn from(err: CredentialsError) -> ListConnectorDefinitionsError {
ListConnectorDefinitionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListConnectorDefinitionsError {
fn from(err: HttpDispatchError) -> ListConnectorDefinitionsError {
ListConnectorDefinitionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListConnectorDefinitionsError {
fn from(err: io::Error) -> ListConnectorDefinitionsError {
ListConnectorDefinitionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListConnectorDefinitionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListConnectorDefinitionsError {
fn description(&self) -> &str {
match *self {
ListConnectorDefinitionsError::Validation(ref cause) => cause,
ListConnectorDefinitionsError::Credentials(ref err) => err.description(),
ListConnectorDefinitionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListConnectorDefinitionsError::ParseError(ref cause) => cause,
ListConnectorDefinitionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListCoreDefinitionVersionsError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListCoreDefinitionVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListCoreDefinitionVersionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListCoreDefinitionVersionsError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return ListCoreDefinitionVersionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListCoreDefinitionVersionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListCoreDefinitionVersionsError {
fn from(err: serde_json::error::Error) -> ListCoreDefinitionVersionsError {
ListCoreDefinitionVersionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListCoreDefinitionVersionsError {
fn from(err: CredentialsError) -> ListCoreDefinitionVersionsError {
ListCoreDefinitionVersionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListCoreDefinitionVersionsError {
fn from(err: HttpDispatchError) -> ListCoreDefinitionVersionsError {
ListCoreDefinitionVersionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListCoreDefinitionVersionsError {
fn from(err: io::Error) -> ListCoreDefinitionVersionsError {
ListCoreDefinitionVersionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListCoreDefinitionVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListCoreDefinitionVersionsError {
fn description(&self) -> &str {
match *self {
ListCoreDefinitionVersionsError::BadRequest(ref cause) => cause,
ListCoreDefinitionVersionsError::Validation(ref cause) => cause,
ListCoreDefinitionVersionsError::Credentials(ref err) => err.description(),
ListCoreDefinitionVersionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListCoreDefinitionVersionsError::ParseError(ref cause) => cause,
ListCoreDefinitionVersionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListCoreDefinitionsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListCoreDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListCoreDefinitionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ValidationException" => {
return ListCoreDefinitionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListCoreDefinitionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListCoreDefinitionsError {
fn from(err: serde_json::error::Error) -> ListCoreDefinitionsError {
ListCoreDefinitionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListCoreDefinitionsError {
fn from(err: CredentialsError) -> ListCoreDefinitionsError {
ListCoreDefinitionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListCoreDefinitionsError {
fn from(err: HttpDispatchError) -> ListCoreDefinitionsError {
ListCoreDefinitionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListCoreDefinitionsError {
fn from(err: io::Error) -> ListCoreDefinitionsError {
ListCoreDefinitionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListCoreDefinitionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListCoreDefinitionsError {
fn description(&self) -> &str {
match *self {
ListCoreDefinitionsError::Validation(ref cause) => cause,
ListCoreDefinitionsError::Credentials(ref err) => err.description(),
ListCoreDefinitionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListCoreDefinitionsError::ParseError(ref cause) => cause,
ListCoreDefinitionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListDeploymentsError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListDeploymentsError {
pub fn from_response(res: BufferedHttpResponse) -> ListDeploymentsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListDeploymentsError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return ListDeploymentsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListDeploymentsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListDeploymentsError {
fn from(err: serde_json::error::Error) -> ListDeploymentsError {
ListDeploymentsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListDeploymentsError {
fn from(err: CredentialsError) -> ListDeploymentsError {
ListDeploymentsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListDeploymentsError {
fn from(err: HttpDispatchError) -> ListDeploymentsError {
ListDeploymentsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListDeploymentsError {
fn from(err: io::Error) -> ListDeploymentsError {
ListDeploymentsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListDeploymentsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListDeploymentsError {
fn description(&self) -> &str {
match *self {
ListDeploymentsError::BadRequest(ref cause) => cause,
ListDeploymentsError::Validation(ref cause) => cause,
ListDeploymentsError::Credentials(ref err) => err.description(),
ListDeploymentsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListDeploymentsError::ParseError(ref cause) => cause,
ListDeploymentsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListDeviceDefinitionVersionsError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListDeviceDefinitionVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListDeviceDefinitionVersionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListDeviceDefinitionVersionsError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return ListDeviceDefinitionVersionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListDeviceDefinitionVersionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListDeviceDefinitionVersionsError {
fn from(err: serde_json::error::Error) -> ListDeviceDefinitionVersionsError {
ListDeviceDefinitionVersionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListDeviceDefinitionVersionsError {
fn from(err: CredentialsError) -> ListDeviceDefinitionVersionsError {
ListDeviceDefinitionVersionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListDeviceDefinitionVersionsError {
fn from(err: HttpDispatchError) -> ListDeviceDefinitionVersionsError {
ListDeviceDefinitionVersionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListDeviceDefinitionVersionsError {
fn from(err: io::Error) -> ListDeviceDefinitionVersionsError {
ListDeviceDefinitionVersionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListDeviceDefinitionVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListDeviceDefinitionVersionsError {
fn description(&self) -> &str {
match *self {
ListDeviceDefinitionVersionsError::BadRequest(ref cause) => cause,
ListDeviceDefinitionVersionsError::Validation(ref cause) => cause,
ListDeviceDefinitionVersionsError::Credentials(ref err) => err.description(),
ListDeviceDefinitionVersionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListDeviceDefinitionVersionsError::ParseError(ref cause) => cause,
ListDeviceDefinitionVersionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListDeviceDefinitionsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListDeviceDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListDeviceDefinitionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ValidationException" => {
return ListDeviceDefinitionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListDeviceDefinitionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListDeviceDefinitionsError {
fn from(err: serde_json::error::Error) -> ListDeviceDefinitionsError {
ListDeviceDefinitionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListDeviceDefinitionsError {
fn from(err: CredentialsError) -> ListDeviceDefinitionsError {
ListDeviceDefinitionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListDeviceDefinitionsError {
fn from(err: HttpDispatchError) -> ListDeviceDefinitionsError {
ListDeviceDefinitionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListDeviceDefinitionsError {
fn from(err: io::Error) -> ListDeviceDefinitionsError {
ListDeviceDefinitionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListDeviceDefinitionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListDeviceDefinitionsError {
fn description(&self) -> &str {
match *self {
ListDeviceDefinitionsError::Validation(ref cause) => cause,
ListDeviceDefinitionsError::Credentials(ref err) => err.description(),
ListDeviceDefinitionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListDeviceDefinitionsError::ParseError(ref cause) => cause,
ListDeviceDefinitionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListFunctionDefinitionVersionsError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListFunctionDefinitionVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListFunctionDefinitionVersionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListFunctionDefinitionVersionsError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return ListFunctionDefinitionVersionsError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return ListFunctionDefinitionVersionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListFunctionDefinitionVersionsError {
fn from(err: serde_json::error::Error) -> ListFunctionDefinitionVersionsError {
ListFunctionDefinitionVersionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListFunctionDefinitionVersionsError {
fn from(err: CredentialsError) -> ListFunctionDefinitionVersionsError {
ListFunctionDefinitionVersionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListFunctionDefinitionVersionsError {
fn from(err: HttpDispatchError) -> ListFunctionDefinitionVersionsError {
ListFunctionDefinitionVersionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListFunctionDefinitionVersionsError {
fn from(err: io::Error) -> ListFunctionDefinitionVersionsError {
ListFunctionDefinitionVersionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListFunctionDefinitionVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListFunctionDefinitionVersionsError {
fn description(&self) -> &str {
match *self {
ListFunctionDefinitionVersionsError::BadRequest(ref cause) => cause,
ListFunctionDefinitionVersionsError::Validation(ref cause) => cause,
ListFunctionDefinitionVersionsError::Credentials(ref err) => err.description(),
ListFunctionDefinitionVersionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListFunctionDefinitionVersionsError::ParseError(ref cause) => cause,
ListFunctionDefinitionVersionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListFunctionDefinitionsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListFunctionDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListFunctionDefinitionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ValidationException" => {
return ListFunctionDefinitionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListFunctionDefinitionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListFunctionDefinitionsError {
fn from(err: serde_json::error::Error) -> ListFunctionDefinitionsError {
ListFunctionDefinitionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListFunctionDefinitionsError {
fn from(err: CredentialsError) -> ListFunctionDefinitionsError {
ListFunctionDefinitionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListFunctionDefinitionsError {
fn from(err: HttpDispatchError) -> ListFunctionDefinitionsError {
ListFunctionDefinitionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListFunctionDefinitionsError {
fn from(err: io::Error) -> ListFunctionDefinitionsError {
ListFunctionDefinitionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListFunctionDefinitionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListFunctionDefinitionsError {
fn description(&self) -> &str {
match *self {
ListFunctionDefinitionsError::Validation(ref cause) => cause,
ListFunctionDefinitionsError::Credentials(ref err) => err.description(),
ListFunctionDefinitionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListFunctionDefinitionsError::ParseError(ref cause) => cause,
ListFunctionDefinitionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListGroupCertificateAuthoritiesError {
BadRequest(String),
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListGroupCertificateAuthoritiesError {
pub fn from_response(res: BufferedHttpResponse) -> ListGroupCertificateAuthoritiesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListGroupCertificateAuthoritiesError::BadRequest(String::from(
error_message,
));
}
"InternalServerErrorException" => {
return ListGroupCertificateAuthoritiesError::InternalServerError(String::from(
error_message,
));
}
"ValidationException" => {
return ListGroupCertificateAuthoritiesError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return ListGroupCertificateAuthoritiesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListGroupCertificateAuthoritiesError {
fn from(err: serde_json::error::Error) -> ListGroupCertificateAuthoritiesError {
ListGroupCertificateAuthoritiesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListGroupCertificateAuthoritiesError {
fn from(err: CredentialsError) -> ListGroupCertificateAuthoritiesError {
ListGroupCertificateAuthoritiesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListGroupCertificateAuthoritiesError {
fn from(err: HttpDispatchError) -> ListGroupCertificateAuthoritiesError {
ListGroupCertificateAuthoritiesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListGroupCertificateAuthoritiesError {
fn from(err: io::Error) -> ListGroupCertificateAuthoritiesError {
ListGroupCertificateAuthoritiesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListGroupCertificateAuthoritiesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListGroupCertificateAuthoritiesError {
fn description(&self) -> &str {
match *self {
ListGroupCertificateAuthoritiesError::BadRequest(ref cause) => cause,
ListGroupCertificateAuthoritiesError::InternalServerError(ref cause) => cause,
ListGroupCertificateAuthoritiesError::Validation(ref cause) => cause,
ListGroupCertificateAuthoritiesError::Credentials(ref err) => err.description(),
ListGroupCertificateAuthoritiesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListGroupCertificateAuthoritiesError::ParseError(ref cause) => cause,
ListGroupCertificateAuthoritiesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListGroupVersionsError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListGroupVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListGroupVersionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListGroupVersionsError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return ListGroupVersionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListGroupVersionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListGroupVersionsError {
fn from(err: serde_json::error::Error) -> ListGroupVersionsError {
ListGroupVersionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListGroupVersionsError {
fn from(err: CredentialsError) -> ListGroupVersionsError {
ListGroupVersionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListGroupVersionsError {
fn from(err: HttpDispatchError) -> ListGroupVersionsError {
ListGroupVersionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListGroupVersionsError {
fn from(err: io::Error) -> ListGroupVersionsError {
ListGroupVersionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListGroupVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListGroupVersionsError {
fn description(&self) -> &str {
match *self {
ListGroupVersionsError::BadRequest(ref cause) => cause,
ListGroupVersionsError::Validation(ref cause) => cause,
ListGroupVersionsError::Credentials(ref err) => err.description(),
ListGroupVersionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListGroupVersionsError::ParseError(ref cause) => cause,
ListGroupVersionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListGroupsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> ListGroupsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ValidationException" => {
return ListGroupsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListGroupsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListGroupsError {
fn from(err: serde_json::error::Error) -> ListGroupsError {
ListGroupsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListGroupsError {
fn from(err: CredentialsError) -> ListGroupsError {
ListGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListGroupsError {
fn from(err: HttpDispatchError) -> ListGroupsError {
ListGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListGroupsError {
fn from(err: io::Error) -> ListGroupsError {
ListGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListGroupsError {
fn description(&self) -> &str {
match *self {
ListGroupsError::Validation(ref cause) => cause,
ListGroupsError::Credentials(ref err) => err.description(),
ListGroupsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListGroupsError::ParseError(ref cause) => cause,
ListGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListLoggerDefinitionVersionsError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListLoggerDefinitionVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListLoggerDefinitionVersionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListLoggerDefinitionVersionsError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return ListLoggerDefinitionVersionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListLoggerDefinitionVersionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListLoggerDefinitionVersionsError {
fn from(err: serde_json::error::Error) -> ListLoggerDefinitionVersionsError {
ListLoggerDefinitionVersionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListLoggerDefinitionVersionsError {
fn from(err: CredentialsError) -> ListLoggerDefinitionVersionsError {
ListLoggerDefinitionVersionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListLoggerDefinitionVersionsError {
fn from(err: HttpDispatchError) -> ListLoggerDefinitionVersionsError {
ListLoggerDefinitionVersionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListLoggerDefinitionVersionsError {
fn from(err: io::Error) -> ListLoggerDefinitionVersionsError {
ListLoggerDefinitionVersionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListLoggerDefinitionVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListLoggerDefinitionVersionsError {
fn description(&self) -> &str {
match *self {
ListLoggerDefinitionVersionsError::BadRequest(ref cause) => cause,
ListLoggerDefinitionVersionsError::Validation(ref cause) => cause,
ListLoggerDefinitionVersionsError::Credentials(ref err) => err.description(),
ListLoggerDefinitionVersionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListLoggerDefinitionVersionsError::ParseError(ref cause) => cause,
ListLoggerDefinitionVersionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListLoggerDefinitionsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListLoggerDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListLoggerDefinitionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ValidationException" => {
return ListLoggerDefinitionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListLoggerDefinitionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListLoggerDefinitionsError {
fn from(err: serde_json::error::Error) -> ListLoggerDefinitionsError {
ListLoggerDefinitionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListLoggerDefinitionsError {
fn from(err: CredentialsError) -> ListLoggerDefinitionsError {
ListLoggerDefinitionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListLoggerDefinitionsError {
fn from(err: HttpDispatchError) -> ListLoggerDefinitionsError {
ListLoggerDefinitionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListLoggerDefinitionsError {
fn from(err: io::Error) -> ListLoggerDefinitionsError {
ListLoggerDefinitionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListLoggerDefinitionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListLoggerDefinitionsError {
fn description(&self) -> &str {
match *self {
ListLoggerDefinitionsError::Validation(ref cause) => cause,
ListLoggerDefinitionsError::Credentials(ref err) => err.description(),
ListLoggerDefinitionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListLoggerDefinitionsError::ParseError(ref cause) => cause,
ListLoggerDefinitionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListResourceDefinitionVersionsError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListResourceDefinitionVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListResourceDefinitionVersionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListResourceDefinitionVersionsError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return ListResourceDefinitionVersionsError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return ListResourceDefinitionVersionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListResourceDefinitionVersionsError {
fn from(err: serde_json::error::Error) -> ListResourceDefinitionVersionsError {
ListResourceDefinitionVersionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListResourceDefinitionVersionsError {
fn from(err: CredentialsError) -> ListResourceDefinitionVersionsError {
ListResourceDefinitionVersionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListResourceDefinitionVersionsError {
fn from(err: HttpDispatchError) -> ListResourceDefinitionVersionsError {
ListResourceDefinitionVersionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListResourceDefinitionVersionsError {
fn from(err: io::Error) -> ListResourceDefinitionVersionsError {
ListResourceDefinitionVersionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListResourceDefinitionVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListResourceDefinitionVersionsError {
fn description(&self) -> &str {
match *self {
ListResourceDefinitionVersionsError::BadRequest(ref cause) => cause,
ListResourceDefinitionVersionsError::Validation(ref cause) => cause,
ListResourceDefinitionVersionsError::Credentials(ref err) => err.description(),
ListResourceDefinitionVersionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListResourceDefinitionVersionsError::ParseError(ref cause) => cause,
ListResourceDefinitionVersionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListResourceDefinitionsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListResourceDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListResourceDefinitionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ValidationException" => {
return ListResourceDefinitionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListResourceDefinitionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListResourceDefinitionsError {
fn from(err: serde_json::error::Error) -> ListResourceDefinitionsError {
ListResourceDefinitionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListResourceDefinitionsError {
fn from(err: CredentialsError) -> ListResourceDefinitionsError {
ListResourceDefinitionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListResourceDefinitionsError {
fn from(err: HttpDispatchError) -> ListResourceDefinitionsError {
ListResourceDefinitionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListResourceDefinitionsError {
fn from(err: io::Error) -> ListResourceDefinitionsError {
ListResourceDefinitionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListResourceDefinitionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListResourceDefinitionsError {
fn description(&self) -> &str {
match *self {
ListResourceDefinitionsError::Validation(ref cause) => cause,
ListResourceDefinitionsError::Credentials(ref err) => err.description(),
ListResourceDefinitionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListResourceDefinitionsError::ParseError(ref cause) => cause,
ListResourceDefinitionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListSubscriptionDefinitionVersionsError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListSubscriptionDefinitionVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListSubscriptionDefinitionVersionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ListSubscriptionDefinitionVersionsError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return ListSubscriptionDefinitionVersionsError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return ListSubscriptionDefinitionVersionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListSubscriptionDefinitionVersionsError {
fn from(err: serde_json::error::Error) -> ListSubscriptionDefinitionVersionsError {
ListSubscriptionDefinitionVersionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListSubscriptionDefinitionVersionsError {
fn from(err: CredentialsError) -> ListSubscriptionDefinitionVersionsError {
ListSubscriptionDefinitionVersionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListSubscriptionDefinitionVersionsError {
fn from(err: HttpDispatchError) -> ListSubscriptionDefinitionVersionsError {
ListSubscriptionDefinitionVersionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListSubscriptionDefinitionVersionsError {
fn from(err: io::Error) -> ListSubscriptionDefinitionVersionsError {
ListSubscriptionDefinitionVersionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListSubscriptionDefinitionVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListSubscriptionDefinitionVersionsError {
fn description(&self) -> &str {
match *self {
ListSubscriptionDefinitionVersionsError::BadRequest(ref cause) => cause,
ListSubscriptionDefinitionVersionsError::Validation(ref cause) => cause,
ListSubscriptionDefinitionVersionsError::Credentials(ref err) => err.description(),
ListSubscriptionDefinitionVersionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListSubscriptionDefinitionVersionsError::ParseError(ref cause) => cause,
ListSubscriptionDefinitionVersionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListSubscriptionDefinitionsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListSubscriptionDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListSubscriptionDefinitionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"ValidationException" => {
return ListSubscriptionDefinitionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListSubscriptionDefinitionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListSubscriptionDefinitionsError {
fn from(err: serde_json::error::Error) -> ListSubscriptionDefinitionsError {
ListSubscriptionDefinitionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListSubscriptionDefinitionsError {
fn from(err: CredentialsError) -> ListSubscriptionDefinitionsError {
ListSubscriptionDefinitionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListSubscriptionDefinitionsError {
fn from(err: HttpDispatchError) -> ListSubscriptionDefinitionsError {
ListSubscriptionDefinitionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListSubscriptionDefinitionsError {
fn from(err: io::Error) -> ListSubscriptionDefinitionsError {
ListSubscriptionDefinitionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListSubscriptionDefinitionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListSubscriptionDefinitionsError {
fn description(&self) -> &str {
match *self {
ListSubscriptionDefinitionsError::Validation(ref cause) => cause,
ListSubscriptionDefinitionsError::Credentials(ref err) => err.description(),
ListSubscriptionDefinitionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListSubscriptionDefinitionsError::ParseError(ref cause) => cause,
ListSubscriptionDefinitionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ResetDeploymentsError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ResetDeploymentsError {
pub fn from_response(res: BufferedHttpResponse) -> ResetDeploymentsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return ResetDeploymentsError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return ResetDeploymentsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ResetDeploymentsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ResetDeploymentsError {
fn from(err: serde_json::error::Error) -> ResetDeploymentsError {
ResetDeploymentsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ResetDeploymentsError {
fn from(err: CredentialsError) -> ResetDeploymentsError {
ResetDeploymentsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ResetDeploymentsError {
fn from(err: HttpDispatchError) -> ResetDeploymentsError {
ResetDeploymentsError::HttpDispatch(err)
}
}
impl From<io::Error> for ResetDeploymentsError {
fn from(err: io::Error) -> ResetDeploymentsError {
ResetDeploymentsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ResetDeploymentsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResetDeploymentsError {
fn description(&self) -> &str {
match *self {
ResetDeploymentsError::BadRequest(ref cause) => cause,
ResetDeploymentsError::Validation(ref cause) => cause,
ResetDeploymentsError::Credentials(ref err) => err.description(),
ResetDeploymentsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ResetDeploymentsError::ParseError(ref cause) => cause,
ResetDeploymentsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartBulkDeploymentError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartBulkDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> StartBulkDeploymentError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return StartBulkDeploymentError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return StartBulkDeploymentError::Validation(error_message.to_string());
}
_ => {}
}
}
return StartBulkDeploymentError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartBulkDeploymentError {
fn from(err: serde_json::error::Error) -> StartBulkDeploymentError {
StartBulkDeploymentError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartBulkDeploymentError {
fn from(err: CredentialsError) -> StartBulkDeploymentError {
StartBulkDeploymentError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartBulkDeploymentError {
fn from(err: HttpDispatchError) -> StartBulkDeploymentError {
StartBulkDeploymentError::HttpDispatch(err)
}
}
impl From<io::Error> for StartBulkDeploymentError {
fn from(err: io::Error) -> StartBulkDeploymentError {
StartBulkDeploymentError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartBulkDeploymentError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartBulkDeploymentError {
fn description(&self) -> &str {
match *self {
StartBulkDeploymentError::BadRequest(ref cause) => cause,
StartBulkDeploymentError::Validation(ref cause) => cause,
StartBulkDeploymentError::Credentials(ref err) => err.description(),
StartBulkDeploymentError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
StartBulkDeploymentError::ParseError(ref cause) => cause,
StartBulkDeploymentError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StopBulkDeploymentError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StopBulkDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> StopBulkDeploymentError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return StopBulkDeploymentError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return StopBulkDeploymentError::Validation(error_message.to_string());
}
_ => {}
}
}
return StopBulkDeploymentError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StopBulkDeploymentError {
fn from(err: serde_json::error::Error) -> StopBulkDeploymentError {
StopBulkDeploymentError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StopBulkDeploymentError {
fn from(err: CredentialsError) -> StopBulkDeploymentError {
StopBulkDeploymentError::Credentials(err)
}
}
impl From<HttpDispatchError> for StopBulkDeploymentError {
fn from(err: HttpDispatchError) -> StopBulkDeploymentError {
StopBulkDeploymentError::HttpDispatch(err)
}
}
impl From<io::Error> for StopBulkDeploymentError {
fn from(err: io::Error) -> StopBulkDeploymentError {
StopBulkDeploymentError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StopBulkDeploymentError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StopBulkDeploymentError {
fn description(&self) -> &str {
match *self {
StopBulkDeploymentError::BadRequest(ref cause) => cause,
StopBulkDeploymentError::Validation(ref cause) => cause,
StopBulkDeploymentError::Credentials(ref err) => err.description(),
StopBulkDeploymentError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
StopBulkDeploymentError::ParseError(ref cause) => cause,
StopBulkDeploymentError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateConnectivityInfoError {
BadRequest(String),
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateConnectivityInfoError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateConnectivityInfoError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UpdateConnectivityInfoError::BadRequest(String::from(error_message));
}
"InternalServerErrorException" => {
return UpdateConnectivityInfoError::InternalServerError(String::from(
error_message,
));
}
"ValidationException" => {
return UpdateConnectivityInfoError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateConnectivityInfoError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateConnectivityInfoError {
fn from(err: serde_json::error::Error) -> UpdateConnectivityInfoError {
UpdateConnectivityInfoError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateConnectivityInfoError {
fn from(err: CredentialsError) -> UpdateConnectivityInfoError {
UpdateConnectivityInfoError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateConnectivityInfoError {
fn from(err: HttpDispatchError) -> UpdateConnectivityInfoError {
UpdateConnectivityInfoError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateConnectivityInfoError {
fn from(err: io::Error) -> UpdateConnectivityInfoError {
UpdateConnectivityInfoError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateConnectivityInfoError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateConnectivityInfoError {
fn description(&self) -> &str {
match *self {
UpdateConnectivityInfoError::BadRequest(ref cause) => cause,
UpdateConnectivityInfoError::InternalServerError(ref cause) => cause,
UpdateConnectivityInfoError::Validation(ref cause) => cause,
UpdateConnectivityInfoError::Credentials(ref err) => err.description(),
UpdateConnectivityInfoError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateConnectivityInfoError::ParseError(ref cause) => cause,
UpdateConnectivityInfoError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateConnectorDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateConnectorDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateConnectorDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UpdateConnectorDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return UpdateConnectorDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateConnectorDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateConnectorDefinitionError {
fn from(err: serde_json::error::Error) -> UpdateConnectorDefinitionError {
UpdateConnectorDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateConnectorDefinitionError {
fn from(err: CredentialsError) -> UpdateConnectorDefinitionError {
UpdateConnectorDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateConnectorDefinitionError {
fn from(err: HttpDispatchError) -> UpdateConnectorDefinitionError {
UpdateConnectorDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateConnectorDefinitionError {
fn from(err: io::Error) -> UpdateConnectorDefinitionError {
UpdateConnectorDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateConnectorDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateConnectorDefinitionError {
fn description(&self) -> &str {
match *self {
UpdateConnectorDefinitionError::BadRequest(ref cause) => cause,
UpdateConnectorDefinitionError::Validation(ref cause) => cause,
UpdateConnectorDefinitionError::Credentials(ref err) => err.description(),
UpdateConnectorDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateConnectorDefinitionError::ParseError(ref cause) => cause,
UpdateConnectorDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateCoreDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateCoreDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateCoreDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UpdateCoreDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return UpdateCoreDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateCoreDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateCoreDefinitionError {
fn from(err: serde_json::error::Error) -> UpdateCoreDefinitionError {
UpdateCoreDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateCoreDefinitionError {
fn from(err: CredentialsError) -> UpdateCoreDefinitionError {
UpdateCoreDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateCoreDefinitionError {
fn from(err: HttpDispatchError) -> UpdateCoreDefinitionError {
UpdateCoreDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateCoreDefinitionError {
fn from(err: io::Error) -> UpdateCoreDefinitionError {
UpdateCoreDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateCoreDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateCoreDefinitionError {
fn description(&self) -> &str {
match *self {
UpdateCoreDefinitionError::BadRequest(ref cause) => cause,
UpdateCoreDefinitionError::Validation(ref cause) => cause,
UpdateCoreDefinitionError::Credentials(ref err) => err.description(),
UpdateCoreDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateCoreDefinitionError::ParseError(ref cause) => cause,
UpdateCoreDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateDeviceDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateDeviceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateDeviceDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UpdateDeviceDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return UpdateDeviceDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateDeviceDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateDeviceDefinitionError {
fn from(err: serde_json::error::Error) -> UpdateDeviceDefinitionError {
UpdateDeviceDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateDeviceDefinitionError {
fn from(err: CredentialsError) -> UpdateDeviceDefinitionError {
UpdateDeviceDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateDeviceDefinitionError {
fn from(err: HttpDispatchError) -> UpdateDeviceDefinitionError {
UpdateDeviceDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateDeviceDefinitionError {
fn from(err: io::Error) -> UpdateDeviceDefinitionError {
UpdateDeviceDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateDeviceDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateDeviceDefinitionError {
fn description(&self) -> &str {
match *self {
UpdateDeviceDefinitionError::BadRequest(ref cause) => cause,
UpdateDeviceDefinitionError::Validation(ref cause) => cause,
UpdateDeviceDefinitionError::Credentials(ref err) => err.description(),
UpdateDeviceDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateDeviceDefinitionError::ParseError(ref cause) => cause,
UpdateDeviceDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateFunctionDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateFunctionDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateFunctionDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UpdateFunctionDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return UpdateFunctionDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateFunctionDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateFunctionDefinitionError {
fn from(err: serde_json::error::Error) -> UpdateFunctionDefinitionError {
UpdateFunctionDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateFunctionDefinitionError {
fn from(err: CredentialsError) -> UpdateFunctionDefinitionError {
UpdateFunctionDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateFunctionDefinitionError {
fn from(err: HttpDispatchError) -> UpdateFunctionDefinitionError {
UpdateFunctionDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateFunctionDefinitionError {
fn from(err: io::Error) -> UpdateFunctionDefinitionError {
UpdateFunctionDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateFunctionDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateFunctionDefinitionError {
fn description(&self) -> &str {
match *self {
UpdateFunctionDefinitionError::BadRequest(ref cause) => cause,
UpdateFunctionDefinitionError::Validation(ref cause) => cause,
UpdateFunctionDefinitionError::Credentials(ref err) => err.description(),
UpdateFunctionDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateFunctionDefinitionError::ParseError(ref cause) => cause,
UpdateFunctionDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateGroupError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateGroupError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateGroupError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UpdateGroupError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return UpdateGroupError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateGroupError {
fn from(err: serde_json::error::Error) -> UpdateGroupError {
UpdateGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateGroupError {
fn from(err: CredentialsError) -> UpdateGroupError {
UpdateGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateGroupError {
fn from(err: HttpDispatchError) -> UpdateGroupError {
UpdateGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateGroupError {
fn from(err: io::Error) -> UpdateGroupError {
UpdateGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateGroupError {
fn description(&self) -> &str {
match *self {
UpdateGroupError::BadRequest(ref cause) => cause,
UpdateGroupError::Validation(ref cause) => cause,
UpdateGroupError::Credentials(ref err) => err.description(),
UpdateGroupError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateGroupError::ParseError(ref cause) => cause,
UpdateGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateGroupCertificateConfigurationError {
BadRequest(String),
InternalServerError(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateGroupCertificateConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateGroupCertificateConfigurationError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UpdateGroupCertificateConfigurationError::BadRequest(String::from(
error_message,
));
}
"InternalServerErrorException" => {
return UpdateGroupCertificateConfigurationError::InternalServerError(
String::from(error_message),
);
}
"ValidationException" => {
return UpdateGroupCertificateConfigurationError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return UpdateGroupCertificateConfigurationError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateGroupCertificateConfigurationError {
fn from(err: serde_json::error::Error) -> UpdateGroupCertificateConfigurationError {
UpdateGroupCertificateConfigurationError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateGroupCertificateConfigurationError {
fn from(err: CredentialsError) -> UpdateGroupCertificateConfigurationError {
UpdateGroupCertificateConfigurationError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateGroupCertificateConfigurationError {
fn from(err: HttpDispatchError) -> UpdateGroupCertificateConfigurationError {
UpdateGroupCertificateConfigurationError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateGroupCertificateConfigurationError {
fn from(err: io::Error) -> UpdateGroupCertificateConfigurationError {
UpdateGroupCertificateConfigurationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateGroupCertificateConfigurationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateGroupCertificateConfigurationError {
fn description(&self) -> &str {
match *self {
UpdateGroupCertificateConfigurationError::BadRequest(ref cause) => cause,
UpdateGroupCertificateConfigurationError::InternalServerError(ref cause) => cause,
UpdateGroupCertificateConfigurationError::Validation(ref cause) => cause,
UpdateGroupCertificateConfigurationError::Credentials(ref err) => err.description(),
UpdateGroupCertificateConfigurationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateGroupCertificateConfigurationError::ParseError(ref cause) => cause,
UpdateGroupCertificateConfigurationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateLoggerDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateLoggerDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateLoggerDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UpdateLoggerDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return UpdateLoggerDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateLoggerDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateLoggerDefinitionError {
fn from(err: serde_json::error::Error) -> UpdateLoggerDefinitionError {
UpdateLoggerDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateLoggerDefinitionError {
fn from(err: CredentialsError) -> UpdateLoggerDefinitionError {
UpdateLoggerDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateLoggerDefinitionError {
fn from(err: HttpDispatchError) -> UpdateLoggerDefinitionError {
UpdateLoggerDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateLoggerDefinitionError {
fn from(err: io::Error) -> UpdateLoggerDefinitionError {
UpdateLoggerDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateLoggerDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateLoggerDefinitionError {
fn description(&self) -> &str {
match *self {
UpdateLoggerDefinitionError::BadRequest(ref cause) => cause,
UpdateLoggerDefinitionError::Validation(ref cause) => cause,
UpdateLoggerDefinitionError::Credentials(ref err) => err.description(),
UpdateLoggerDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateLoggerDefinitionError::ParseError(ref cause) => cause,
UpdateLoggerDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateResourceDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateResourceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateResourceDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UpdateResourceDefinitionError::BadRequest(String::from(error_message));
}
"ValidationException" => {
return UpdateResourceDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateResourceDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateResourceDefinitionError {
fn from(err: serde_json::error::Error) -> UpdateResourceDefinitionError {
UpdateResourceDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateResourceDefinitionError {
fn from(err: CredentialsError) -> UpdateResourceDefinitionError {
UpdateResourceDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateResourceDefinitionError {
fn from(err: HttpDispatchError) -> UpdateResourceDefinitionError {
UpdateResourceDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateResourceDefinitionError {
fn from(err: io::Error) -> UpdateResourceDefinitionError {
UpdateResourceDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateResourceDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateResourceDefinitionError {
fn description(&self) -> &str {
match *self {
UpdateResourceDefinitionError::BadRequest(ref cause) => cause,
UpdateResourceDefinitionError::Validation(ref cause) => cause,
UpdateResourceDefinitionError::Credentials(ref err) => err.description(),
UpdateResourceDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateResourceDefinitionError::ParseError(ref cause) => cause,
UpdateResourceDefinitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateSubscriptionDefinitionError {
BadRequest(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateSubscriptionDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateSubscriptionDefinitionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let error_type = match res.headers.get("x-amzn-errortype") {
Some(raw_error_type) => raw_error_type
.split(':')
.next()
.unwrap_or_else(|| "Unknown"),
_ => json
.get("code")
.or_else(|| json.get("Code"))
.and_then(|c| c.as_str())
.unwrap_or_else(|| "Unknown"),
};
let error_message = json
.get("message")
.or_else(|| json.get("Message"))
.and_then(|m| m.as_str())
.unwrap_or("");
match error_type {
"BadRequestException" => {
return UpdateSubscriptionDefinitionError::BadRequest(String::from(
error_message,
));
}
"ValidationException" => {
return UpdateSubscriptionDefinitionError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateSubscriptionDefinitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateSubscriptionDefinitionError {
fn from(err: serde_json::error::Error) -> UpdateSubscriptionDefinitionError {
UpdateSubscriptionDefinitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateSubscriptionDefinitionError {
fn from(err: CredentialsError) -> UpdateSubscriptionDefinitionError {
UpdateSubscriptionDefinitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateSubscriptionDefinitionError {
fn from(err: HttpDispatchError) -> UpdateSubscriptionDefinitionError {
UpdateSubscriptionDefinitionError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateSubscriptionDefinitionError {
fn from(err: io::Error) -> UpdateSubscriptionDefinitionError {
UpdateSubscriptionDefinitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateSubscriptionDefinitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateSubscriptionDefinitionError {
fn description(&self) -> &str {
match *self {
UpdateSubscriptionDefinitionError::BadRequest(ref cause) => cause,
UpdateSubscriptionDefinitionError::Validation(ref cause) => cause,
UpdateSubscriptionDefinitionError::Credentials(ref err) => err.description(),
UpdateSubscriptionDefinitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateSubscriptionDefinitionError::ParseError(ref cause) => cause,
UpdateSubscriptionDefinitionError::Unknown(_) => "unknown error",
}
}
}
pub trait GreenGrass {
fn associate_role_to_group(
&self,
input: AssociateRoleToGroupRequest,
) -> RusotoFuture<AssociateRoleToGroupResponse, AssociateRoleToGroupError>;
fn associate_service_role_to_account(
&self,
input: AssociateServiceRoleToAccountRequest,
) -> RusotoFuture<AssociateServiceRoleToAccountResponse, AssociateServiceRoleToAccountError>;
fn create_connector_definition(
&self,
input: CreateConnectorDefinitionRequest,
) -> RusotoFuture<CreateConnectorDefinitionResponse, CreateConnectorDefinitionError>;
fn create_connector_definition_version(
&self,
input: CreateConnectorDefinitionVersionRequest,
) -> RusotoFuture<CreateConnectorDefinitionVersionResponse, CreateConnectorDefinitionVersionError>;
fn create_core_definition(
&self,
input: CreateCoreDefinitionRequest,
) -> RusotoFuture<CreateCoreDefinitionResponse, CreateCoreDefinitionError>;
fn create_core_definition_version(
&self,
input: CreateCoreDefinitionVersionRequest,
) -> RusotoFuture<CreateCoreDefinitionVersionResponse, CreateCoreDefinitionVersionError>;
fn create_deployment(
&self,
input: CreateDeploymentRequest,
) -> RusotoFuture<CreateDeploymentResponse, CreateDeploymentError>;
fn create_device_definition(
&self,
input: CreateDeviceDefinitionRequest,
) -> RusotoFuture<CreateDeviceDefinitionResponse, CreateDeviceDefinitionError>;
fn create_device_definition_version(
&self,
input: CreateDeviceDefinitionVersionRequest,
) -> RusotoFuture<CreateDeviceDefinitionVersionResponse, CreateDeviceDefinitionVersionError>;
fn create_function_definition(
&self,
input: CreateFunctionDefinitionRequest,
) -> RusotoFuture<CreateFunctionDefinitionResponse, CreateFunctionDefinitionError>;
fn create_function_definition_version(
&self,
input: CreateFunctionDefinitionVersionRequest,
) -> RusotoFuture<CreateFunctionDefinitionVersionResponse, CreateFunctionDefinitionVersionError>;
fn create_group(
&self,
input: CreateGroupRequest,
) -> RusotoFuture<CreateGroupResponse, CreateGroupError>;
fn create_group_certificate_authority(
&self,
input: CreateGroupCertificateAuthorityRequest,
) -> RusotoFuture<CreateGroupCertificateAuthorityResponse, CreateGroupCertificateAuthorityError>;
fn create_group_version(
&self,
input: CreateGroupVersionRequest,
) -> RusotoFuture<CreateGroupVersionResponse, CreateGroupVersionError>;
fn create_logger_definition(
&self,
input: CreateLoggerDefinitionRequest,
) -> RusotoFuture<CreateLoggerDefinitionResponse, CreateLoggerDefinitionError>;
fn create_logger_definition_version(
&self,
input: CreateLoggerDefinitionVersionRequest,
) -> RusotoFuture<CreateLoggerDefinitionVersionResponse, CreateLoggerDefinitionVersionError>;
fn create_resource_definition(
&self,
input: CreateResourceDefinitionRequest,
) -> RusotoFuture<CreateResourceDefinitionResponse, CreateResourceDefinitionError>;
fn create_resource_definition_version(
&self,
input: CreateResourceDefinitionVersionRequest,
) -> RusotoFuture<CreateResourceDefinitionVersionResponse, CreateResourceDefinitionVersionError>;
fn create_software_update_job(
&self,
input: CreateSoftwareUpdateJobRequest,
) -> RusotoFuture<CreateSoftwareUpdateJobResponse, CreateSoftwareUpdateJobError>;
fn create_subscription_definition(
&self,
input: CreateSubscriptionDefinitionRequest,
) -> RusotoFuture<CreateSubscriptionDefinitionResponse, CreateSubscriptionDefinitionError>;
fn create_subscription_definition_version(
&self,
input: CreateSubscriptionDefinitionVersionRequest,
) -> RusotoFuture<
CreateSubscriptionDefinitionVersionResponse,
CreateSubscriptionDefinitionVersionError,
>;
fn delete_connector_definition(
&self,
input: DeleteConnectorDefinitionRequest,
) -> RusotoFuture<DeleteConnectorDefinitionResponse, DeleteConnectorDefinitionError>;
fn delete_core_definition(
&self,
input: DeleteCoreDefinitionRequest,
) -> RusotoFuture<DeleteCoreDefinitionResponse, DeleteCoreDefinitionError>;
fn delete_device_definition(
&self,
input: DeleteDeviceDefinitionRequest,
) -> RusotoFuture<DeleteDeviceDefinitionResponse, DeleteDeviceDefinitionError>;
fn delete_function_definition(
&self,
input: DeleteFunctionDefinitionRequest,
) -> RusotoFuture<DeleteFunctionDefinitionResponse, DeleteFunctionDefinitionError>;
fn delete_group(
&self,
input: DeleteGroupRequest,
) -> RusotoFuture<DeleteGroupResponse, DeleteGroupError>;
fn delete_logger_definition(
&self,
input: DeleteLoggerDefinitionRequest,
) -> RusotoFuture<DeleteLoggerDefinitionResponse, DeleteLoggerDefinitionError>;
fn delete_resource_definition(
&self,
input: DeleteResourceDefinitionRequest,
) -> RusotoFuture<DeleteResourceDefinitionResponse, DeleteResourceDefinitionError>;
fn delete_subscription_definition(
&self,
input: DeleteSubscriptionDefinitionRequest,
) -> RusotoFuture<DeleteSubscriptionDefinitionResponse, DeleteSubscriptionDefinitionError>;
fn disassociate_role_from_group(
&self,
input: DisassociateRoleFromGroupRequest,
) -> RusotoFuture<DisassociateRoleFromGroupResponse, DisassociateRoleFromGroupError>;
fn disassociate_service_role_from_account(
&self,
) -> RusotoFuture<
DisassociateServiceRoleFromAccountResponse,
DisassociateServiceRoleFromAccountError,
>;
fn get_associated_role(
&self,
input: GetAssociatedRoleRequest,
) -> RusotoFuture<GetAssociatedRoleResponse, GetAssociatedRoleError>;
fn get_bulk_deployment_status(
&self,
input: GetBulkDeploymentStatusRequest,
) -> RusotoFuture<GetBulkDeploymentStatusResponse, GetBulkDeploymentStatusError>;
fn get_connectivity_info(
&self,
input: GetConnectivityInfoRequest,
) -> RusotoFuture<GetConnectivityInfoResponse, GetConnectivityInfoError>;
fn get_connector_definition(
&self,
input: GetConnectorDefinitionRequest,
) -> RusotoFuture<GetConnectorDefinitionResponse, GetConnectorDefinitionError>;
fn get_connector_definition_version(
&self,
input: GetConnectorDefinitionVersionRequest,
) -> RusotoFuture<GetConnectorDefinitionVersionResponse, GetConnectorDefinitionVersionError>;
fn get_core_definition(
&self,
input: GetCoreDefinitionRequest,
) -> RusotoFuture<GetCoreDefinitionResponse, GetCoreDefinitionError>;
fn get_core_definition_version(
&self,
input: GetCoreDefinitionVersionRequest,
) -> RusotoFuture<GetCoreDefinitionVersionResponse, GetCoreDefinitionVersionError>;
fn get_deployment_status(
&self,
input: GetDeploymentStatusRequest,
) -> RusotoFuture<GetDeploymentStatusResponse, GetDeploymentStatusError>;
fn get_device_definition(
&self,
input: GetDeviceDefinitionRequest,
) -> RusotoFuture<GetDeviceDefinitionResponse, GetDeviceDefinitionError>;
fn get_device_definition_version(
&self,
input: GetDeviceDefinitionVersionRequest,
) -> RusotoFuture<GetDeviceDefinitionVersionResponse, GetDeviceDefinitionVersionError>;
fn get_function_definition(
&self,
input: GetFunctionDefinitionRequest,
) -> RusotoFuture<GetFunctionDefinitionResponse, GetFunctionDefinitionError>;
fn get_function_definition_version(
&self,
input: GetFunctionDefinitionVersionRequest,
) -> RusotoFuture<GetFunctionDefinitionVersionResponse, GetFunctionDefinitionVersionError>;
fn get_group(&self, input: GetGroupRequest) -> RusotoFuture<GetGroupResponse, GetGroupError>;
fn get_group_certificate_authority(
&self,
input: GetGroupCertificateAuthorityRequest,
) -> RusotoFuture<GetGroupCertificateAuthorityResponse, GetGroupCertificateAuthorityError>;
fn get_group_certificate_configuration(
&self,
input: GetGroupCertificateConfigurationRequest,
) -> RusotoFuture<GetGroupCertificateConfigurationResponse, GetGroupCertificateConfigurationError>;
fn get_group_version(
&self,
input: GetGroupVersionRequest,
) -> RusotoFuture<GetGroupVersionResponse, GetGroupVersionError>;
fn get_logger_definition(
&self,
input: GetLoggerDefinitionRequest,
) -> RusotoFuture<GetLoggerDefinitionResponse, GetLoggerDefinitionError>;
fn get_logger_definition_version(
&self,
input: GetLoggerDefinitionVersionRequest,
) -> RusotoFuture<GetLoggerDefinitionVersionResponse, GetLoggerDefinitionVersionError>;
fn get_resource_definition(
&self,
input: GetResourceDefinitionRequest,
) -> RusotoFuture<GetResourceDefinitionResponse, GetResourceDefinitionError>;
fn get_resource_definition_version(
&self,
input: GetResourceDefinitionVersionRequest,
) -> RusotoFuture<GetResourceDefinitionVersionResponse, GetResourceDefinitionVersionError>;
fn get_service_role_for_account(
&self,
) -> RusotoFuture<GetServiceRoleForAccountResponse, GetServiceRoleForAccountError>;
fn get_subscription_definition(
&self,
input: GetSubscriptionDefinitionRequest,
) -> RusotoFuture<GetSubscriptionDefinitionResponse, GetSubscriptionDefinitionError>;
fn get_subscription_definition_version(
&self,
input: GetSubscriptionDefinitionVersionRequest,
) -> RusotoFuture<GetSubscriptionDefinitionVersionResponse, GetSubscriptionDefinitionVersionError>;
fn list_bulk_deployment_detailed_reports(
&self,
input: ListBulkDeploymentDetailedReportsRequest,
) -> RusotoFuture<
ListBulkDeploymentDetailedReportsResponse,
ListBulkDeploymentDetailedReportsError,
>;
fn list_bulk_deployments(
&self,
input: ListBulkDeploymentsRequest,
) -> RusotoFuture<ListBulkDeploymentsResponse, ListBulkDeploymentsError>;
fn list_connector_definition_versions(
&self,
input: ListConnectorDefinitionVersionsRequest,
) -> RusotoFuture<ListConnectorDefinitionVersionsResponse, ListConnectorDefinitionVersionsError>;
fn list_connector_definitions(
&self,
input: ListConnectorDefinitionsRequest,
) -> RusotoFuture<ListConnectorDefinitionsResponse, ListConnectorDefinitionsError>;
fn list_core_definition_versions(
&self,
input: ListCoreDefinitionVersionsRequest,
) -> RusotoFuture<ListCoreDefinitionVersionsResponse, ListCoreDefinitionVersionsError>;
fn list_core_definitions(
&self,
input: ListCoreDefinitionsRequest,
) -> RusotoFuture<ListCoreDefinitionsResponse, ListCoreDefinitionsError>;
fn list_deployments(
&self,
input: ListDeploymentsRequest,
) -> RusotoFuture<ListDeploymentsResponse, ListDeploymentsError>;
fn list_device_definition_versions(
&self,
input: ListDeviceDefinitionVersionsRequest,
) -> RusotoFuture<ListDeviceDefinitionVersionsResponse, ListDeviceDefinitionVersionsError>;
fn list_device_definitions(
&self,
input: ListDeviceDefinitionsRequest,
) -> RusotoFuture<ListDeviceDefinitionsResponse, ListDeviceDefinitionsError>;
fn list_function_definition_versions(
&self,
input: ListFunctionDefinitionVersionsRequest,
) -> RusotoFuture<ListFunctionDefinitionVersionsResponse, ListFunctionDefinitionVersionsError>;
fn list_function_definitions(
&self,
input: ListFunctionDefinitionsRequest,
) -> RusotoFuture<ListFunctionDefinitionsResponse, ListFunctionDefinitionsError>;
fn list_group_certificate_authorities(
&self,
input: ListGroupCertificateAuthoritiesRequest,
) -> RusotoFuture<ListGroupCertificateAuthoritiesResponse, ListGroupCertificateAuthoritiesError>;
fn list_group_versions(
&self,
input: ListGroupVersionsRequest,
) -> RusotoFuture<ListGroupVersionsResponse, ListGroupVersionsError>;
fn list_groups(
&self,
input: ListGroupsRequest,
) -> RusotoFuture<ListGroupsResponse, ListGroupsError>;
fn list_logger_definition_versions(
&self,
input: ListLoggerDefinitionVersionsRequest,
) -> RusotoFuture<ListLoggerDefinitionVersionsResponse, ListLoggerDefinitionVersionsError>;
fn list_logger_definitions(
&self,
input: ListLoggerDefinitionsRequest,
) -> RusotoFuture<ListLoggerDefinitionsResponse, ListLoggerDefinitionsError>;
fn list_resource_definition_versions(
&self,
input: ListResourceDefinitionVersionsRequest,
) -> RusotoFuture<ListResourceDefinitionVersionsResponse, ListResourceDefinitionVersionsError>;
fn list_resource_definitions(
&self,
input: ListResourceDefinitionsRequest,
) -> RusotoFuture<ListResourceDefinitionsResponse, ListResourceDefinitionsError>;
fn list_subscription_definition_versions(
&self,
input: ListSubscriptionDefinitionVersionsRequest,
) -> RusotoFuture<
ListSubscriptionDefinitionVersionsResponse,
ListSubscriptionDefinitionVersionsError,
>;
fn list_subscription_definitions(
&self,
input: ListSubscriptionDefinitionsRequest,
) -> RusotoFuture<ListSubscriptionDefinitionsResponse, ListSubscriptionDefinitionsError>;
fn reset_deployments(
&self,
input: ResetDeploymentsRequest,
) -> RusotoFuture<ResetDeploymentsResponse, ResetDeploymentsError>;
fn start_bulk_deployment(
&self,
input: StartBulkDeploymentRequest,
) -> RusotoFuture<StartBulkDeploymentResponse, StartBulkDeploymentError>;
fn stop_bulk_deployment(
&self,
input: StopBulkDeploymentRequest,
) -> RusotoFuture<StopBulkDeploymentResponse, StopBulkDeploymentError>;
fn update_connectivity_info(
&self,
input: UpdateConnectivityInfoRequest,
) -> RusotoFuture<UpdateConnectivityInfoResponse, UpdateConnectivityInfoError>;
fn update_connector_definition(
&self,
input: UpdateConnectorDefinitionRequest,
) -> RusotoFuture<UpdateConnectorDefinitionResponse, UpdateConnectorDefinitionError>;
fn update_core_definition(
&self,
input: UpdateCoreDefinitionRequest,
) -> RusotoFuture<UpdateCoreDefinitionResponse, UpdateCoreDefinitionError>;
fn update_device_definition(
&self,
input: UpdateDeviceDefinitionRequest,
) -> RusotoFuture<UpdateDeviceDefinitionResponse, UpdateDeviceDefinitionError>;
fn update_function_definition(
&self,
input: UpdateFunctionDefinitionRequest,
) -> RusotoFuture<UpdateFunctionDefinitionResponse, UpdateFunctionDefinitionError>;
fn update_group(
&self,
input: UpdateGroupRequest,
) -> RusotoFuture<UpdateGroupResponse, UpdateGroupError>;
fn update_group_certificate_configuration(
&self,
input: UpdateGroupCertificateConfigurationRequest,
) -> RusotoFuture<
UpdateGroupCertificateConfigurationResponse,
UpdateGroupCertificateConfigurationError,
>;
fn update_logger_definition(
&self,
input: UpdateLoggerDefinitionRequest,
) -> RusotoFuture<UpdateLoggerDefinitionResponse, UpdateLoggerDefinitionError>;
fn update_resource_definition(
&self,
input: UpdateResourceDefinitionRequest,
) -> RusotoFuture<UpdateResourceDefinitionResponse, UpdateResourceDefinitionError>;
fn update_subscription_definition(
&self,
input: UpdateSubscriptionDefinitionRequest,
) -> RusotoFuture<UpdateSubscriptionDefinitionResponse, UpdateSubscriptionDefinitionError>;
}
#[derive(Clone)]
pub struct GreenGrassClient {
client: Client,
region: region::Region,
}
impl GreenGrassClient {
pub fn new(region: region::Region) -> GreenGrassClient {
GreenGrassClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> GreenGrassClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
GreenGrassClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl GreenGrass for GreenGrassClient {
fn associate_role_to_group(
&self,
input: AssociateRoleToGroupRequest,
) -> RusotoFuture<AssociateRoleToGroupResponse, AssociateRoleToGroupError> {
let request_uri = format!(
"/greengrass/groups/{group_id}/role",
group_id = input.group_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<AssociateRoleToGroupResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(AssociateRoleToGroupError::from_response(response))
}),
)
}
})
}
fn associate_service_role_to_account(
&self,
input: AssociateServiceRoleToAccountRequest,
) -> RusotoFuture<AssociateServiceRoleToAccountResponse, AssociateServiceRoleToAccountError>
{
let request_uri = "/greengrass/servicerole";
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<AssociateServiceRoleToAccountResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(AssociateServiceRoleToAccountError::from_response(response))
}))
}
})
}
fn create_connector_definition(
&self,
input: CreateConnectorDefinitionRequest,
) -> RusotoFuture<CreateConnectorDefinitionResponse, CreateConnectorDefinitionError> {
let request_uri = "/greengrass/definition/connectors";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateConnectorDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateConnectorDefinitionError::from_response(response))
}))
}
})
}
fn create_connector_definition_version(
&self,
input: CreateConnectorDefinitionVersionRequest,
) -> RusotoFuture<CreateConnectorDefinitionVersionResponse, CreateConnectorDefinitionVersionError>
{
let request_uri = format!(
"/greengrass/definition/connectors/{connector_definition_id}/versions",
connector_definition_id = input.connector_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateConnectorDefinitionVersionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateConnectorDefinitionVersionError::from_response(
response,
))
}))
}
})
}
fn create_core_definition(
&self,
input: CreateCoreDefinitionRequest,
) -> RusotoFuture<CreateCoreDefinitionResponse, CreateCoreDefinitionError> {
let request_uri = "/greengrass/definition/cores";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateCoreDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateCoreDefinitionError::from_response(response))
}),
)
}
})
}
fn create_core_definition_version(
&self,
input: CreateCoreDefinitionVersionRequest,
) -> RusotoFuture<CreateCoreDefinitionVersionResponse, CreateCoreDefinitionVersionError> {
let request_uri = format!(
"/greengrass/definition/cores/{core_definition_id}/versions",
core_definition_id = input.core_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateCoreDefinitionVersionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateCoreDefinitionVersionError::from_response(response))
}))
}
})
}
fn create_deployment(
&self,
input: CreateDeploymentRequest,
) -> RusotoFuture<CreateDeploymentResponse, CreateDeploymentError> {
let request_uri = format!(
"/greengrass/groups/{group_id}/deployments",
group_id = input.group_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<CreateDeploymentResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateDeploymentError::from_response(response))),
)
}
})
}
fn create_device_definition(
&self,
input: CreateDeviceDefinitionRequest,
) -> RusotoFuture<CreateDeviceDefinitionResponse, CreateDeviceDefinitionError> {
let request_uri = "/greengrass/definition/devices";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateDeviceDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateDeviceDefinitionError::from_response(response))
}),
)
}
})
}
fn create_device_definition_version(
&self,
input: CreateDeviceDefinitionVersionRequest,
) -> RusotoFuture<CreateDeviceDefinitionVersionResponse, CreateDeviceDefinitionVersionError>
{
let request_uri = format!(
"/greengrass/definition/devices/{device_definition_id}/versions",
device_definition_id = input.device_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateDeviceDefinitionVersionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateDeviceDefinitionVersionError::from_response(response))
}))
}
})
}
fn create_function_definition(
&self,
input: CreateFunctionDefinitionRequest,
) -> RusotoFuture<CreateFunctionDefinitionResponse, CreateFunctionDefinitionError> {
let request_uri = "/greengrass/definition/functions";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateFunctionDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateFunctionDefinitionError::from_response(response))
}))
}
})
}
fn create_function_definition_version(
&self,
input: CreateFunctionDefinitionVersionRequest,
) -> RusotoFuture<CreateFunctionDefinitionVersionResponse, CreateFunctionDefinitionVersionError>
{
let request_uri = format!(
"/greengrass/definition/functions/{function_definition_id}/versions",
function_definition_id = input.function_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateFunctionDefinitionVersionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateFunctionDefinitionVersionError::from_response(
response,
))
}))
}
})
}
fn create_group(
&self,
input: CreateGroupRequest,
) -> RusotoFuture<CreateGroupResponse, CreateGroupError> {
let request_uri = "/greengrass/groups";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<CreateGroupResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateGroupError::from_response(response))),
)
}
})
}
fn create_group_certificate_authority(
&self,
input: CreateGroupCertificateAuthorityRequest,
) -> RusotoFuture<CreateGroupCertificateAuthorityResponse, CreateGroupCertificateAuthorityError>
{
let request_uri = format!(
"/greengrass/groups/{group_id}/certificateauthorities",
group_id = input.group_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateGroupCertificateAuthorityResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateGroupCertificateAuthorityError::from_response(
response,
))
}))
}
})
}
fn create_group_version(
&self,
input: CreateGroupVersionRequest,
) -> RusotoFuture<CreateGroupVersionResponse, CreateGroupVersionError> {
let request_uri = format!(
"/greengrass/groups/{group_id}/versions",
group_id = input.group_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateGroupVersionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateGroupVersionError::from_response(response))),
)
}
})
}
fn create_logger_definition(
&self,
input: CreateLoggerDefinitionRequest,
) -> RusotoFuture<CreateLoggerDefinitionResponse, CreateLoggerDefinitionError> {
let request_uri = "/greengrass/definition/loggers";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateLoggerDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateLoggerDefinitionError::from_response(response))
}),
)
}
})
}
fn create_logger_definition_version(
&self,
input: CreateLoggerDefinitionVersionRequest,
) -> RusotoFuture<CreateLoggerDefinitionVersionResponse, CreateLoggerDefinitionVersionError>
{
let request_uri = format!(
"/greengrass/definition/loggers/{logger_definition_id}/versions",
logger_definition_id = input.logger_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateLoggerDefinitionVersionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateLoggerDefinitionVersionError::from_response(response))
}))
}
})
}
fn create_resource_definition(
&self,
input: CreateResourceDefinitionRequest,
) -> RusotoFuture<CreateResourceDefinitionResponse, CreateResourceDefinitionError> {
let request_uri = "/greengrass/definition/resources";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateResourceDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateResourceDefinitionError::from_response(response))
}))
}
})
}
fn create_resource_definition_version(
&self,
input: CreateResourceDefinitionVersionRequest,
) -> RusotoFuture<CreateResourceDefinitionVersionResponse, CreateResourceDefinitionVersionError>
{
let request_uri = format!(
"/greengrass/definition/resources/{resource_definition_id}/versions",
resource_definition_id = input.resource_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateResourceDefinitionVersionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateResourceDefinitionVersionError::from_response(
response,
))
}))
}
})
}
fn create_software_update_job(
&self,
input: CreateSoftwareUpdateJobRequest,
) -> RusotoFuture<CreateSoftwareUpdateJobResponse, CreateSoftwareUpdateJobError> {
let request_uri = "/greengrass/updates";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateSoftwareUpdateJobResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateSoftwareUpdateJobError::from_response(response))
}))
}
})
}
fn create_subscription_definition(
&self,
input: CreateSubscriptionDefinitionRequest,
) -> RusotoFuture<CreateSubscriptionDefinitionResponse, CreateSubscriptionDefinitionError> {
let request_uri = "/greengrass/definition/subscriptions";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<CreateSubscriptionDefinitionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateSubscriptionDefinitionError::from_response(response))
}))
}
})
}
fn create_subscription_definition_version(
&self,
input: CreateSubscriptionDefinitionVersionRequest,
) -> RusotoFuture<
CreateSubscriptionDefinitionVersionResponse,
CreateSubscriptionDefinitionVersionError,
> {
let request_uri = format!(
"/greengrass/definition/subscriptions/{subscription_definition_id}/versions",
subscription_definition_id = input.subscription_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<
CreateSubscriptionDefinitionVersionResponse,
>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateSubscriptionDefinitionVersionError::from_response(
response,
))
}))
}
})
}
fn delete_connector_definition(
&self,
input: DeleteConnectorDefinitionRequest,
) -> RusotoFuture<DeleteConnectorDefinitionResponse, DeleteConnectorDefinitionError> {
let request_uri = format!(
"/greengrass/definition/connectors/{connector_definition_id}",
connector_definition_id = input.connector_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<DeleteConnectorDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteConnectorDefinitionError::from_response(response))
}))
}
})
}
fn delete_core_definition(
&self,
input: DeleteCoreDefinitionRequest,
) -> RusotoFuture<DeleteCoreDefinitionResponse, DeleteCoreDefinitionError> {
let request_uri = format!(
"/greengrass/definition/cores/{core_definition_id}",
core_definition_id = input.core_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<DeleteCoreDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteCoreDefinitionError::from_response(response))
}),
)
}
})
}
fn delete_device_definition(
&self,
input: DeleteDeviceDefinitionRequest,
) -> RusotoFuture<DeleteDeviceDefinitionResponse, DeleteDeviceDefinitionError> {
let request_uri = format!(
"/greengrass/definition/devices/{device_definition_id}",
device_definition_id = input.device_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<DeleteDeviceDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteDeviceDefinitionError::from_response(response))
}),
)
}
})
}
fn delete_function_definition(
&self,
input: DeleteFunctionDefinitionRequest,
) -> RusotoFuture<DeleteFunctionDefinitionResponse, DeleteFunctionDefinitionError> {
let request_uri = format!(
"/greengrass/definition/functions/{function_definition_id}",
function_definition_id = input.function_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<DeleteFunctionDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteFunctionDefinitionError::from_response(response))
}))
}
})
}
fn delete_group(
&self,
input: DeleteGroupRequest,
) -> RusotoFuture<DeleteGroupResponse, DeleteGroupError> {
let request_uri = format!("/greengrass/groups/{group_id}", group_id = input.group_id);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<DeleteGroupResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteGroupError::from_response(response))),
)
}
})
}
fn delete_logger_definition(
&self,
input: DeleteLoggerDefinitionRequest,
) -> RusotoFuture<DeleteLoggerDefinitionResponse, DeleteLoggerDefinitionError> {
let request_uri = format!(
"/greengrass/definition/loggers/{logger_definition_id}",
logger_definition_id = input.logger_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<DeleteLoggerDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteLoggerDefinitionError::from_response(response))
}),
)
}
})
}
fn delete_resource_definition(
&self,
input: DeleteResourceDefinitionRequest,
) -> RusotoFuture<DeleteResourceDefinitionResponse, DeleteResourceDefinitionError> {
let request_uri = format!(
"/greengrass/definition/resources/{resource_definition_id}",
resource_definition_id = input.resource_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<DeleteResourceDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteResourceDefinitionError::from_response(response))
}))
}
})
}
fn delete_subscription_definition(
&self,
input: DeleteSubscriptionDefinitionRequest,
) -> RusotoFuture<DeleteSubscriptionDefinitionResponse, DeleteSubscriptionDefinitionError> {
let request_uri = format!(
"/greengrass/definition/subscriptions/{subscription_definition_id}",
subscription_definition_id = input.subscription_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<DeleteSubscriptionDefinitionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteSubscriptionDefinitionError::from_response(response))
}))
}
})
}
fn disassociate_role_from_group(
&self,
input: DisassociateRoleFromGroupRequest,
) -> RusotoFuture<DisassociateRoleFromGroupResponse, DisassociateRoleFromGroupError> {
let request_uri = format!(
"/greengrass/groups/{group_id}/role",
group_id = input.group_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<DisassociateRoleFromGroupResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateRoleFromGroupError::from_response(response))
}))
}
})
}
fn disassociate_service_role_from_account(
&self,
) -> RusotoFuture<
DisassociateServiceRoleFromAccountResponse,
DisassociateServiceRoleFromAccountError,
> {
let request_uri = "/greengrass/servicerole";
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<DisassociateServiceRoleFromAccountResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateServiceRoleFromAccountError::from_response(
response,
))
}))
}
})
}
fn get_associated_role(
&self,
input: GetAssociatedRoleRequest,
) -> RusotoFuture<GetAssociatedRoleResponse, GetAssociatedRoleError> {
let request_uri = format!(
"/greengrass/groups/{group_id}/role",
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetAssociatedRoleResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetAssociatedRoleError::from_response(response))),
)
}
})
}
fn get_bulk_deployment_status(
&self,
input: GetBulkDeploymentStatusRequest,
) -> RusotoFuture<GetBulkDeploymentStatusResponse, GetBulkDeploymentStatusError> {
let request_uri = format!(
"/greengrass/bulk/deployments/{bulk_deployment_id}/status",
bulk_deployment_id = input.bulk_deployment_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetBulkDeploymentStatusResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetBulkDeploymentStatusError::from_response(response))
}))
}
})
}
fn get_connectivity_info(
&self,
input: GetConnectivityInfoRequest,
) -> RusotoFuture<GetConnectivityInfoResponse, GetConnectivityInfoError> {
let request_uri = format!(
"/greengrass/things/{thing_name}/connectivityInfo",
thing_name = input.thing_name
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetConnectivityInfoResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetConnectivityInfoError::from_response(response))
}),
)
}
})
}
fn get_connector_definition(
&self,
input: GetConnectorDefinitionRequest,
) -> RusotoFuture<GetConnectorDefinitionResponse, GetConnectorDefinitionError> {
let request_uri = format!(
"/greengrass/definition/connectors/{connector_definition_id}",
connector_definition_id = input.connector_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetConnectorDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetConnectorDefinitionError::from_response(response))
}),
)
}
})
}
fn get_connector_definition_version(
&self,
input: GetConnectorDefinitionVersionRequest,
) -> RusotoFuture<GetConnectorDefinitionVersionResponse, GetConnectorDefinitionVersionError>
{
let request_uri = format!("/greengrass/definition/connectors/{connector_definition_id}/versions/{connector_definition_version_id}", connector_definition_id = input.connector_definition_id, connector_definition_version_id = input.connector_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetConnectorDefinitionVersionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetConnectorDefinitionVersionError::from_response(response))
}))
}
})
}
fn get_core_definition(
&self,
input: GetCoreDefinitionRequest,
) -> RusotoFuture<GetCoreDefinitionResponse, GetCoreDefinitionError> {
let request_uri = format!(
"/greengrass/definition/cores/{core_definition_id}",
core_definition_id = input.core_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetCoreDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetCoreDefinitionError::from_response(response))),
)
}
})
}
fn get_core_definition_version(
&self,
input: GetCoreDefinitionVersionRequest,
) -> RusotoFuture<GetCoreDefinitionVersionResponse, GetCoreDefinitionVersionError> {
let request_uri = format!("/greengrass/definition/cores/{core_definition_id}/versions/{core_definition_version_id}", core_definition_id = input.core_definition_id, core_definition_version_id = input.core_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetCoreDefinitionVersionResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetCoreDefinitionVersionError::from_response(response))
}))
}
})
}
fn get_deployment_status(
&self,
input: GetDeploymentStatusRequest,
) -> RusotoFuture<GetDeploymentStatusResponse, GetDeploymentStatusError> {
let request_uri = format!(
"/greengrass/groups/{group_id}/deployments/{deployment_id}/status",
deployment_id = input.deployment_id,
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetDeploymentStatusResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetDeploymentStatusError::from_response(response))
}),
)
}
})
}
fn get_device_definition(
&self,
input: GetDeviceDefinitionRequest,
) -> RusotoFuture<GetDeviceDefinitionResponse, GetDeviceDefinitionError> {
let request_uri = format!(
"/greengrass/definition/devices/{device_definition_id}",
device_definition_id = input.device_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetDeviceDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetDeviceDefinitionError::from_response(response))
}),
)
}
})
}
fn get_device_definition_version(
&self,
input: GetDeviceDefinitionVersionRequest,
) -> RusotoFuture<GetDeviceDefinitionVersionResponse, GetDeviceDefinitionVersionError> {
let request_uri = format!("/greengrass/definition/devices/{device_definition_id}/versions/{device_definition_version_id}", device_definition_id = input.device_definition_id, device_definition_version_id = input.device_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetDeviceDefinitionVersionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetDeviceDefinitionVersionError::from_response(response))
}))
}
})
}
fn get_function_definition(
&self,
input: GetFunctionDefinitionRequest,
) -> RusotoFuture<GetFunctionDefinitionResponse, GetFunctionDefinitionError> {
let request_uri = format!(
"/greengrass/definition/functions/{function_definition_id}",
function_definition_id = input.function_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetFunctionDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetFunctionDefinitionError::from_response(response))
}),
)
}
})
}
fn get_function_definition_version(
&self,
input: GetFunctionDefinitionVersionRequest,
) -> RusotoFuture<GetFunctionDefinitionVersionResponse, GetFunctionDefinitionVersionError> {
let request_uri = format!("/greengrass/definition/functions/{function_definition_id}/versions/{function_definition_version_id}", function_definition_id = input.function_definition_id, function_definition_version_id = input.function_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetFunctionDefinitionVersionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetFunctionDefinitionVersionError::from_response(response))
}))
}
})
}
fn get_group(&self, input: GetGroupRequest) -> RusotoFuture<GetGroupResponse, GetGroupError> {
let request_uri = format!("/greengrass/groups/{group_id}", group_id = input.group_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<GetGroupResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetGroupError::from_response(response))),
)
}
})
}
fn get_group_certificate_authority(
&self,
input: GetGroupCertificateAuthorityRequest,
) -> RusotoFuture<GetGroupCertificateAuthorityResponse, GetGroupCertificateAuthorityError> {
let request_uri = format!(
"/greengrass/groups/{group_id}/certificateauthorities/{certificate_authority_id}",
certificate_authority_id = input.certificate_authority_id,
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetGroupCertificateAuthorityResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetGroupCertificateAuthorityError::from_response(response))
}))
}
})
}
fn get_group_certificate_configuration(
&self,
input: GetGroupCertificateConfigurationRequest,
) -> RusotoFuture<GetGroupCertificateConfigurationResponse, GetGroupCertificateConfigurationError>
{
let request_uri = format!(
"/greengrass/groups/{group_id}/certificateauthorities/configuration/expiry",
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetGroupCertificateConfigurationResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetGroupCertificateConfigurationError::from_response(
response,
))
}))
}
})
}
fn get_group_version(
&self,
input: GetGroupVersionRequest,
) -> RusotoFuture<GetGroupVersionResponse, GetGroupVersionError> {
let request_uri = format!(
"/greengrass/groups/{group_id}/versions/{group_version_id}",
group_id = input.group_id,
group_version_id = input.group_version_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<GetGroupVersionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetGroupVersionError::from_response(response))),
)
}
})
}
fn get_logger_definition(
&self,
input: GetLoggerDefinitionRequest,
) -> RusotoFuture<GetLoggerDefinitionResponse, GetLoggerDefinitionError> {
let request_uri = format!(
"/greengrass/definition/loggers/{logger_definition_id}",
logger_definition_id = input.logger_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetLoggerDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetLoggerDefinitionError::from_response(response))
}),
)
}
})
}
fn get_logger_definition_version(
&self,
input: GetLoggerDefinitionVersionRequest,
) -> RusotoFuture<GetLoggerDefinitionVersionResponse, GetLoggerDefinitionVersionError> {
let request_uri = format!("/greengrass/definition/loggers/{logger_definition_id}/versions/{logger_definition_version_id}", logger_definition_id = input.logger_definition_id, logger_definition_version_id = input.logger_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetLoggerDefinitionVersionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetLoggerDefinitionVersionError::from_response(response))
}))
}
})
}
fn get_resource_definition(
&self,
input: GetResourceDefinitionRequest,
) -> RusotoFuture<GetResourceDefinitionResponse, GetResourceDefinitionError> {
let request_uri = format!(
"/greengrass/definition/resources/{resource_definition_id}",
resource_definition_id = input.resource_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetResourceDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetResourceDefinitionError::from_response(response))
}),
)
}
})
}
fn get_resource_definition_version(
&self,
input: GetResourceDefinitionVersionRequest,
) -> RusotoFuture<GetResourceDefinitionVersionResponse, GetResourceDefinitionVersionError> {
let request_uri = format!("/greengrass/definition/resources/{resource_definition_id}/versions/{resource_definition_version_id}", resource_definition_id = input.resource_definition_id, resource_definition_version_id = input.resource_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetResourceDefinitionVersionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetResourceDefinitionVersionError::from_response(response))
}))
}
})
}
fn get_service_role_for_account(
&self,
) -> RusotoFuture<GetServiceRoleForAccountResponse, GetServiceRoleForAccountError> {
let request_uri = "/greengrass/servicerole";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetServiceRoleForAccountResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetServiceRoleForAccountError::from_response(response))
}))
}
})
}
fn get_subscription_definition(
&self,
input: GetSubscriptionDefinitionRequest,
) -> RusotoFuture<GetSubscriptionDefinitionResponse, GetSubscriptionDefinitionError> {
let request_uri = format!(
"/greengrass/definition/subscriptions/{subscription_definition_id}",
subscription_definition_id = input.subscription_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetSubscriptionDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetSubscriptionDefinitionError::from_response(response))
}))
}
})
}
fn get_subscription_definition_version(
&self,
input: GetSubscriptionDefinitionVersionRequest,
) -> RusotoFuture<GetSubscriptionDefinitionVersionResponse, GetSubscriptionDefinitionVersionError>
{
let request_uri = format!("/greengrass/definition/subscriptions/{subscription_definition_id}/versions/{subscription_definition_version_id}", subscription_definition_id = input.subscription_definition_id, subscription_definition_version_id = input.subscription_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<GetSubscriptionDefinitionVersionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetSubscriptionDefinitionVersionError::from_response(
response,
))
}))
}
})
}
fn list_bulk_deployment_detailed_reports(
&self,
input: ListBulkDeploymentDetailedReportsRequest,
) -> RusotoFuture<
ListBulkDeploymentDetailedReportsResponse,
ListBulkDeploymentDetailedReportsError,
> {
let request_uri = format!(
"/greengrass/bulk/deployments/{bulk_deployment_id}/detailed-reports",
bulk_deployment_id = input.bulk_deployment_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListBulkDeploymentDetailedReportsResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListBulkDeploymentDetailedReportsError::from_response(
response,
))
}))
}
})
}
fn list_bulk_deployments(
&self,
input: ListBulkDeploymentsRequest,
) -> RusotoFuture<ListBulkDeploymentsResponse, ListBulkDeploymentsError> {
let request_uri = "/greengrass/bulk/deployments";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListBulkDeploymentsResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListBulkDeploymentsError::from_response(response))
}),
)
}
})
}
fn list_connector_definition_versions(
&self,
input: ListConnectorDefinitionVersionsRequest,
) -> RusotoFuture<ListConnectorDefinitionVersionsResponse, ListConnectorDefinitionVersionsError>
{
let request_uri = format!(
"/greengrass/definition/connectors/{connector_definition_id}/versions",
connector_definition_id = input.connector_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListConnectorDefinitionVersionsResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListConnectorDefinitionVersionsError::from_response(
response,
))
}))
}
})
}
fn list_connector_definitions(
&self,
input: ListConnectorDefinitionsRequest,
) -> RusotoFuture<ListConnectorDefinitionsResponse, ListConnectorDefinitionsError> {
let request_uri = "/greengrass/definition/connectors";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListConnectorDefinitionsResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListConnectorDefinitionsError::from_response(response))
}))
}
})
}
fn list_core_definition_versions(
&self,
input: ListCoreDefinitionVersionsRequest,
) -> RusotoFuture<ListCoreDefinitionVersionsResponse, ListCoreDefinitionVersionsError> {
let request_uri = format!(
"/greengrass/definition/cores/{core_definition_id}/versions",
core_definition_id = input.core_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListCoreDefinitionVersionsResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListCoreDefinitionVersionsError::from_response(response))
}))
}
})
}
fn list_core_definitions(
&self,
input: ListCoreDefinitionsRequest,
) -> RusotoFuture<ListCoreDefinitionsResponse, ListCoreDefinitionsError> {
let request_uri = "/greengrass/definition/cores";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListCoreDefinitionsResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListCoreDefinitionsError::from_response(response))
}),
)
}
})
}
fn list_deployments(
&self,
input: ListDeploymentsRequest,
) -> RusotoFuture<ListDeploymentsResponse, ListDeploymentsError> {
let request_uri = format!(
"/greengrass/groups/{group_id}/deployments",
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<ListDeploymentsResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListDeploymentsError::from_response(response))),
)
}
})
}
fn list_device_definition_versions(
&self,
input: ListDeviceDefinitionVersionsRequest,
) -> RusotoFuture<ListDeviceDefinitionVersionsResponse, ListDeviceDefinitionVersionsError> {
let request_uri = format!(
"/greengrass/definition/devices/{device_definition_id}/versions",
device_definition_id = input.device_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListDeviceDefinitionVersionsResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListDeviceDefinitionVersionsError::from_response(response))
}))
}
})
}
fn list_device_definitions(
&self,
input: ListDeviceDefinitionsRequest,
) -> RusotoFuture<ListDeviceDefinitionsResponse, ListDeviceDefinitionsError> {
let request_uri = "/greengrass/definition/devices";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListDeviceDefinitionsResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListDeviceDefinitionsError::from_response(response))
}),
)
}
})
}
fn list_function_definition_versions(
&self,
input: ListFunctionDefinitionVersionsRequest,
) -> RusotoFuture<ListFunctionDefinitionVersionsResponse, ListFunctionDefinitionVersionsError>
{
let request_uri = format!(
"/greengrass/definition/functions/{function_definition_id}/versions",
function_definition_id = input.function_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListFunctionDefinitionVersionsResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListFunctionDefinitionVersionsError::from_response(response))
}))
}
})
}
fn list_function_definitions(
&self,
input: ListFunctionDefinitionsRequest,
) -> RusotoFuture<ListFunctionDefinitionsResponse, ListFunctionDefinitionsError> {
let request_uri = "/greengrass/definition/functions";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListFunctionDefinitionsResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListFunctionDefinitionsError::from_response(response))
}))
}
})
}
fn list_group_certificate_authorities(
&self,
input: ListGroupCertificateAuthoritiesRequest,
) -> RusotoFuture<ListGroupCertificateAuthoritiesResponse, ListGroupCertificateAuthoritiesError>
{
let request_uri = format!(
"/greengrass/groups/{group_id}/certificateauthorities",
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListGroupCertificateAuthoritiesResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListGroupCertificateAuthoritiesError::from_response(
response,
))
}))
}
})
}
fn list_group_versions(
&self,
input: ListGroupVersionsRequest,
) -> RusotoFuture<ListGroupVersionsResponse, ListGroupVersionsError> {
let request_uri = format!(
"/greengrass/groups/{group_id}/versions",
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListGroupVersionsResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListGroupVersionsError::from_response(response))),
)
}
})
}
fn list_groups(
&self,
input: ListGroupsRequest,
) -> RusotoFuture<ListGroupsResponse, ListGroupsError> {
let request_uri = "/greengrass/groups";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<ListGroupsResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListGroupsError::from_response(response))),
)
}
})
}
fn list_logger_definition_versions(
&self,
input: ListLoggerDefinitionVersionsRequest,
) -> RusotoFuture<ListLoggerDefinitionVersionsResponse, ListLoggerDefinitionVersionsError> {
let request_uri = format!(
"/greengrass/definition/loggers/{logger_definition_id}/versions",
logger_definition_id = input.logger_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListLoggerDefinitionVersionsResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListLoggerDefinitionVersionsError::from_response(response))
}))
}
})
}
fn list_logger_definitions(
&self,
input: ListLoggerDefinitionsRequest,
) -> RusotoFuture<ListLoggerDefinitionsResponse, ListLoggerDefinitionsError> {
let request_uri = "/greengrass/definition/loggers";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListLoggerDefinitionsResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListLoggerDefinitionsError::from_response(response))
}),
)
}
})
}
fn list_resource_definition_versions(
&self,
input: ListResourceDefinitionVersionsRequest,
) -> RusotoFuture<ListResourceDefinitionVersionsResponse, ListResourceDefinitionVersionsError>
{
let request_uri = format!(
"/greengrass/definition/resources/{resource_definition_id}/versions",
resource_definition_id = input.resource_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListResourceDefinitionVersionsResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListResourceDefinitionVersionsError::from_response(response))
}))
}
})
}
fn list_resource_definitions(
&self,
input: ListResourceDefinitionsRequest,
) -> RusotoFuture<ListResourceDefinitionsResponse, ListResourceDefinitionsError> {
let request_uri = "/greengrass/definition/resources";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListResourceDefinitionsResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListResourceDefinitionsError::from_response(response))
}))
}
})
}
fn list_subscription_definition_versions(
&self,
input: ListSubscriptionDefinitionVersionsRequest,
) -> RusotoFuture<
ListSubscriptionDefinitionVersionsResponse,
ListSubscriptionDefinitionVersionsError,
> {
let request_uri = format!(
"/greengrass/definition/subscriptions/{subscription_definition_id}/versions",
subscription_definition_id = input.subscription_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListSubscriptionDefinitionVersionsResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListSubscriptionDefinitionVersionsError::from_response(
response,
))
}))
}
})
}
fn list_subscription_definitions(
&self,
input: ListSubscriptionDefinitionsRequest,
) -> RusotoFuture<ListSubscriptionDefinitionsResponse, ListSubscriptionDefinitionsError> {
let request_uri = "/greengrass/definition/subscriptions";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
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);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<ListSubscriptionDefinitionsResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListSubscriptionDefinitionsError::from_response(response))
}))
}
})
}
fn reset_deployments(
&self,
input: ResetDeploymentsRequest,
) -> RusotoFuture<ResetDeploymentsResponse, ResetDeploymentsError> {
let request_uri = format!(
"/greengrass/groups/{group_id}/deployments/$reset",
group_id = input.group_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<ResetDeploymentsResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ResetDeploymentsError::from_response(response))),
)
}
})
}
fn start_bulk_deployment(
&self,
input: StartBulkDeploymentRequest,
) -> RusotoFuture<StartBulkDeploymentResponse, StartBulkDeploymentError> {
let request_uri = "/greengrass/bulk/deployments";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
if let Some(ref amzn_client_token) = input.amzn_client_token {
request.add_header("X-Amzn-Client-Token", &amzn_client_token.to_string());
}
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<StartBulkDeploymentResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(StartBulkDeploymentError::from_response(response))
}),
)
}
})
}
fn stop_bulk_deployment(
&self,
input: StopBulkDeploymentRequest,
) -> RusotoFuture<StopBulkDeploymentResponse, StopBulkDeploymentError> {
let request_uri = format!(
"/greengrass/bulk/deployments/{bulk_deployment_id}/$stop",
bulk_deployment_id = input.bulk_deployment_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<StopBulkDeploymentResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StopBulkDeploymentError::from_response(response))),
)
}
})
}
fn update_connectivity_info(
&self,
input: UpdateConnectivityInfoRequest,
) -> RusotoFuture<UpdateConnectivityInfoResponse, UpdateConnectivityInfoError> {
let request_uri = format!(
"/greengrass/things/{thing_name}/connectivityInfo",
thing_name = input.thing_name
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<UpdateConnectivityInfoResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(UpdateConnectivityInfoError::from_response(response))
}),
)
}
})
}
fn update_connector_definition(
&self,
input: UpdateConnectorDefinitionRequest,
) -> RusotoFuture<UpdateConnectorDefinitionResponse, UpdateConnectorDefinitionError> {
let request_uri = format!(
"/greengrass/definition/connectors/{connector_definition_id}",
connector_definition_id = input.connector_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<UpdateConnectorDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateConnectorDefinitionError::from_response(response))
}))
}
})
}
fn update_core_definition(
&self,
input: UpdateCoreDefinitionRequest,
) -> RusotoFuture<UpdateCoreDefinitionResponse, UpdateCoreDefinitionError> {
let request_uri = format!(
"/greengrass/definition/cores/{core_definition_id}",
core_definition_id = input.core_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<UpdateCoreDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(UpdateCoreDefinitionError::from_response(response))
}),
)
}
})
}
fn update_device_definition(
&self,
input: UpdateDeviceDefinitionRequest,
) -> RusotoFuture<UpdateDeviceDefinitionResponse, UpdateDeviceDefinitionError> {
let request_uri = format!(
"/greengrass/definition/devices/{device_definition_id}",
device_definition_id = input.device_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<UpdateDeviceDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(UpdateDeviceDefinitionError::from_response(response))
}),
)
}
})
}
fn update_function_definition(
&self,
input: UpdateFunctionDefinitionRequest,
) -> RusotoFuture<UpdateFunctionDefinitionResponse, UpdateFunctionDefinitionError> {
let request_uri = format!(
"/greengrass/definition/functions/{function_definition_id}",
function_definition_id = input.function_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<UpdateFunctionDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateFunctionDefinitionError::from_response(response))
}))
}
})
}
fn update_group(
&self,
input: UpdateGroupRequest,
) -> RusotoFuture<UpdateGroupResponse, UpdateGroupError> {
let request_uri = format!("/greengrass/groups/{group_id}", group_id = input.group_id);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<UpdateGroupResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateGroupError::from_response(response))),
)
}
})
}
fn update_group_certificate_configuration(
&self,
input: UpdateGroupCertificateConfigurationRequest,
) -> RusotoFuture<
UpdateGroupCertificateConfigurationResponse,
UpdateGroupCertificateConfigurationError,
> {
let request_uri = format!(
"/greengrass/groups/{group_id}/certificateauthorities/configuration/expiry",
group_id = input.group_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result = serde_json::from_slice::<
UpdateGroupCertificateConfigurationResponse,
>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateGroupCertificateConfigurationError::from_response(
response,
))
}))
}
})
}
fn update_logger_definition(
&self,
input: UpdateLoggerDefinitionRequest,
) -> RusotoFuture<UpdateLoggerDefinitionResponse, UpdateLoggerDefinitionError> {
let request_uri = format!(
"/greengrass/definition/loggers/{logger_definition_id}",
logger_definition_id = input.logger_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<UpdateLoggerDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(UpdateLoggerDefinitionError::from_response(response))
}),
)
}
})
}
fn update_resource_definition(
&self,
input: UpdateResourceDefinitionRequest,
) -> RusotoFuture<UpdateResourceDefinitionResponse, UpdateResourceDefinitionError> {
let request_uri = format!(
"/greengrass/definition/resources/{resource_definition_id}",
resource_definition_id = input.resource_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<UpdateResourceDefinitionResponse>(&body).unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateResourceDefinitionError::from_response(response))
}))
}
})
}
fn update_subscription_definition(
&self,
input: UpdateSubscriptionDefinitionRequest,
) -> RusotoFuture<UpdateSubscriptionDefinitionResponse, UpdateSubscriptionDefinitionError> {
let request_uri = format!(
"/greengrass/definition/subscriptions/{subscription_definition_id}",
subscription_definition_id = input.subscription_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
self.client.sign_and_dispatch(request, |response| {
if response.status.as_u16() == 200 {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body == b"null" || body.is_empty() {
body = b"{}".to_vec();
}
debug!("Response body: {:?}", body);
debug!("Response status: {}", response.status);
let result =
serde_json::from_slice::<UpdateSubscriptionDefinitionResponse>(&body)
.unwrap();
result
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateSubscriptionDefinitionError::from_response(response))
}))
}
})
}
}
#[cfg(test)]
mod protocol_tests {}