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::signature::SignedRequest;
use serde_json;
use serde_json::from_slice;
use serde_json::Value as SerdeJsonValue;
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AddApplicationCloudWatchLoggingOptionRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CloudWatchLoggingOption")]
pub cloud_watch_logging_option: CloudWatchLoggingOption,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AddApplicationCloudWatchLoggingOptionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AddApplicationInputProcessingConfigurationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "InputId")]
pub input_id: String,
#[serde(rename = "InputProcessingConfiguration")]
pub input_processing_configuration: InputProcessingConfiguration,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AddApplicationInputProcessingConfigurationResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AddApplicationInputRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "Input")]
pub input: Input,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AddApplicationInputResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AddApplicationOutputRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "Output")]
pub output: Output,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AddApplicationOutputResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AddApplicationReferenceDataSourceRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "ReferenceDataSource")]
pub reference_data_source: ReferenceDataSource,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AddApplicationReferenceDataSourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ApplicationDetail {
#[serde(rename = "ApplicationARN")]
pub application_arn: String,
#[serde(rename = "ApplicationCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_code: Option<String>,
#[serde(rename = "ApplicationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_description: Option<String>,
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "ApplicationStatus")]
pub application_status: String,
#[serde(rename = "ApplicationVersionId")]
pub application_version_id: i64,
#[serde(rename = "CloudWatchLoggingOptionDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logging_option_descriptions: Option<Vec<CloudWatchLoggingOptionDescription>>,
#[serde(rename = "CreateTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_timestamp: Option<f64>,
#[serde(rename = "InputDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_descriptions: Option<Vec<InputDescription>>,
#[serde(rename = "LastUpdateTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_timestamp: Option<f64>,
#[serde(rename = "OutputDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_descriptions: Option<Vec<OutputDescription>>,
#[serde(rename = "ReferenceDataSourceDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference_data_source_descriptions: Option<Vec<ReferenceDataSourceDescription>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ApplicationSummary {
#[serde(rename = "ApplicationARN")]
pub application_arn: String,
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "ApplicationStatus")]
pub application_status: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ApplicationUpdate {
#[serde(rename = "ApplicationCodeUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_code_update: Option<String>,
#[serde(rename = "CloudWatchLoggingOptionUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logging_option_updates: Option<Vec<CloudWatchLoggingOptionUpdate>>,
#[serde(rename = "InputUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_updates: Option<Vec<InputUpdate>>,
#[serde(rename = "OutputUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_updates: Option<Vec<OutputUpdate>>,
#[serde(rename = "ReferenceDataSourceUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference_data_source_updates: Option<Vec<ReferenceDataSourceUpdate>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CSVMappingParameters {
#[serde(rename = "RecordColumnDelimiter")]
pub record_column_delimiter: String,
#[serde(rename = "RecordRowDelimiter")]
pub record_row_delimiter: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CloudWatchLoggingOption {
#[serde(rename = "LogStreamARN")]
pub log_stream_arn: String,
#[serde(rename = "RoleARN")]
pub role_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CloudWatchLoggingOptionDescription {
#[serde(rename = "CloudWatchLoggingOptionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logging_option_id: Option<String>,
#[serde(rename = "LogStreamARN")]
pub log_stream_arn: String,
#[serde(rename = "RoleARN")]
pub role_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CloudWatchLoggingOptionUpdate {
#[serde(rename = "CloudWatchLoggingOptionId")]
pub cloud_watch_logging_option_id: String,
#[serde(rename = "LogStreamARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_stream_arn_update: Option<String>,
#[serde(rename = "RoleARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateApplicationRequest {
#[serde(rename = "ApplicationCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_code: Option<String>,
#[serde(rename = "ApplicationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_description: Option<String>,
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CloudWatchLoggingOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logging_options: Option<Vec<CloudWatchLoggingOption>>,
#[serde(rename = "Inputs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inputs: Option<Vec<Input>>,
#[serde(rename = "Outputs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub outputs: Option<Vec<Output>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateApplicationResponse {
#[serde(rename = "ApplicationSummary")]
pub application_summary: ApplicationSummary,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteApplicationCloudWatchLoggingOptionRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CloudWatchLoggingOptionId")]
pub cloud_watch_logging_option_id: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteApplicationCloudWatchLoggingOptionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteApplicationInputProcessingConfigurationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "InputId")]
pub input_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteApplicationInputProcessingConfigurationResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteApplicationOutputRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "OutputId")]
pub output_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteApplicationOutputResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteApplicationReferenceDataSourceRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "ReferenceId")]
pub reference_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteApplicationReferenceDataSourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteApplicationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CreateTimestamp")]
pub create_timestamp: f64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteApplicationResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeApplicationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeApplicationResponse {
#[serde(rename = "ApplicationDetail")]
pub application_detail: ApplicationDetail,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DestinationSchema {
#[serde(rename = "RecordFormatType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_format_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DiscoverInputSchemaRequest {
#[serde(rename = "InputProcessingConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_processing_configuration: Option<InputProcessingConfiguration>,
#[serde(rename = "InputStartingPositionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_starting_position_configuration: Option<InputStartingPositionConfiguration>,
#[serde(rename = "ResourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "RoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "S3Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_configuration: Option<S3Configuration>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DiscoverInputSchemaResponse {
#[serde(rename = "InputSchema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_schema: Option<SourceSchema>,
#[serde(rename = "ParsedInputRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parsed_input_records: Option<Vec<Vec<String>>>,
#[serde(rename = "ProcessedInputRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub processed_input_records: Option<Vec<String>>,
#[serde(rename = "RawInputRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub raw_input_records: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct Input {
#[serde(rename = "InputParallelism")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_parallelism: Option<InputParallelism>,
#[serde(rename = "InputProcessingConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_processing_configuration: Option<InputProcessingConfiguration>,
#[serde(rename = "InputSchema")]
pub input_schema: SourceSchema,
#[serde(rename = "KinesisFirehoseInput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_input: Option<KinesisFirehoseInput>,
#[serde(rename = "KinesisStreamsInput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_streams_input: Option<KinesisStreamsInput>,
#[serde(rename = "NamePrefix")]
pub name_prefix: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct InputConfiguration {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "InputStartingPositionConfiguration")]
pub input_starting_position_configuration: InputStartingPositionConfiguration,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct InputDescription {
#[serde(rename = "InAppStreamNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub in_app_stream_names: Option<Vec<String>>,
#[serde(rename = "InputId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_id: Option<String>,
#[serde(rename = "InputParallelism")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_parallelism: Option<InputParallelism>,
#[serde(rename = "InputProcessingConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_processing_configuration_description: Option<InputProcessingConfigurationDescription>,
#[serde(rename = "InputSchema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_schema: Option<SourceSchema>,
#[serde(rename = "InputStartingPositionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_starting_position_configuration: Option<InputStartingPositionConfiguration>,
#[serde(rename = "KinesisFirehoseInputDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_input_description: Option<KinesisFirehoseInputDescription>,
#[serde(rename = "KinesisStreamsInputDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_streams_input_description: Option<KinesisStreamsInputDescription>,
#[serde(rename = "NamePrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name_prefix: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct InputLambdaProcessor {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "RoleARN")]
pub role_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct InputLambdaProcessorDescription {
#[serde(rename = "ResourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: 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 InputLambdaProcessorUpdate {
#[serde(rename = "ResourceARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn_update: Option<String>,
#[serde(rename = "RoleARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InputParallelism {
#[serde(rename = "Count")]
#[serde(skip_serializing_if = "Option::is_none")]
pub count: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct InputParallelismUpdate {
#[serde(rename = "CountUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub count_update: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct InputProcessingConfiguration {
#[serde(rename = "InputLambdaProcessor")]
pub input_lambda_processor: InputLambdaProcessor,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct InputProcessingConfigurationDescription {
#[serde(rename = "InputLambdaProcessorDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_lambda_processor_description: Option<InputLambdaProcessorDescription>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct InputProcessingConfigurationUpdate {
#[serde(rename = "InputLambdaProcessorUpdate")]
pub input_lambda_processor_update: InputLambdaProcessorUpdate,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct InputSchemaUpdate {
#[serde(rename = "RecordColumnUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_column_updates: Option<Vec<RecordColumn>>,
#[serde(rename = "RecordEncodingUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_encoding_update: Option<String>,
#[serde(rename = "RecordFormatUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_format_update: Option<RecordFormat>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InputStartingPositionConfiguration {
#[serde(rename = "InputStartingPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_starting_position: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct InputUpdate {
#[serde(rename = "InputId")]
pub input_id: String,
#[serde(rename = "InputParallelismUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_parallelism_update: Option<InputParallelismUpdate>,
#[serde(rename = "InputProcessingConfigurationUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_processing_configuration_update: Option<InputProcessingConfigurationUpdate>,
#[serde(rename = "InputSchemaUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_schema_update: Option<InputSchemaUpdate>,
#[serde(rename = "KinesisFirehoseInputUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_input_update: Option<KinesisFirehoseInputUpdate>,
#[serde(rename = "KinesisStreamsInputUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_streams_input_update: Option<KinesisStreamsInputUpdate>,
#[serde(rename = "NamePrefixUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name_prefix_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct JSONMappingParameters {
#[serde(rename = "RecordRowPath")]
pub record_row_path: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct KinesisFirehoseInput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "RoleARN")]
pub role_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct KinesisFirehoseInputDescription {
#[serde(rename = "ResourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: 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 KinesisFirehoseInputUpdate {
#[serde(rename = "ResourceARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn_update: Option<String>,
#[serde(rename = "RoleARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct KinesisFirehoseOutput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "RoleARN")]
pub role_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct KinesisFirehoseOutputDescription {
#[serde(rename = "ResourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: 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 KinesisFirehoseOutputUpdate {
#[serde(rename = "ResourceARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn_update: Option<String>,
#[serde(rename = "RoleARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct KinesisStreamsInput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "RoleARN")]
pub role_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct KinesisStreamsInputDescription {
#[serde(rename = "ResourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: 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 KinesisStreamsInputUpdate {
#[serde(rename = "ResourceARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn_update: Option<String>,
#[serde(rename = "RoleARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct KinesisStreamsOutput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "RoleARN")]
pub role_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct KinesisStreamsOutputDescription {
#[serde(rename = "ResourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: 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 KinesisStreamsOutputUpdate {
#[serde(rename = "ResourceARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn_update: Option<String>,
#[serde(rename = "RoleARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct LambdaOutput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "RoleARN")]
pub role_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct LambdaOutputDescription {
#[serde(rename = "ResourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: 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 LambdaOutputUpdate {
#[serde(rename = "ResourceARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn_update: Option<String>,
#[serde(rename = "RoleARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListApplicationsRequest {
#[serde(rename = "ExclusiveStartApplicationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclusive_start_application_name: Option<String>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListApplicationsResponse {
#[serde(rename = "ApplicationSummaries")]
pub application_summaries: Vec<ApplicationSummary>,
#[serde(rename = "HasMoreApplications")]
pub has_more_applications: bool,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MappingParameters {
#[serde(rename = "CSVMappingParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub csv_mapping_parameters: Option<CSVMappingParameters>,
#[serde(rename = "JSONMappingParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub json_mapping_parameters: Option<JSONMappingParameters>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct Output {
#[serde(rename = "DestinationSchema")]
pub destination_schema: DestinationSchema,
#[serde(rename = "KinesisFirehoseOutput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_output: Option<KinesisFirehoseOutput>,
#[serde(rename = "KinesisStreamsOutput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_streams_output: Option<KinesisStreamsOutput>,
#[serde(rename = "LambdaOutput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_output: Option<LambdaOutput>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct OutputDescription {
#[serde(rename = "DestinationSchema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_schema: Option<DestinationSchema>,
#[serde(rename = "KinesisFirehoseOutputDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_output_description: Option<KinesisFirehoseOutputDescription>,
#[serde(rename = "KinesisStreamsOutputDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_streams_output_description: Option<KinesisStreamsOutputDescription>,
#[serde(rename = "LambdaOutputDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_output_description: Option<LambdaOutputDescription>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "OutputId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct OutputUpdate {
#[serde(rename = "DestinationSchemaUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_schema_update: Option<DestinationSchema>,
#[serde(rename = "KinesisFirehoseOutputUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_output_update: Option<KinesisFirehoseOutputUpdate>,
#[serde(rename = "KinesisStreamsOutputUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_streams_output_update: Option<KinesisStreamsOutputUpdate>,
#[serde(rename = "LambdaOutputUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_output_update: Option<LambdaOutputUpdate>,
#[serde(rename = "NameUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name_update: Option<String>,
#[serde(rename = "OutputId")]
pub output_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RecordColumn {
#[serde(rename = "Mapping")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mapping: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SqlType")]
pub sql_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RecordFormat {
#[serde(rename = "MappingParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mapping_parameters: Option<MappingParameters>,
#[serde(rename = "RecordFormatType")]
pub record_format_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ReferenceDataSource {
#[serde(rename = "ReferenceSchema")]
pub reference_schema: SourceSchema,
#[serde(rename = "S3ReferenceDataSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_reference_data_source: Option<S3ReferenceDataSource>,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ReferenceDataSourceDescription {
#[serde(rename = "ReferenceId")]
pub reference_id: String,
#[serde(rename = "ReferenceSchema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference_schema: Option<SourceSchema>,
#[serde(rename = "S3ReferenceDataSourceDescription")]
pub s3_reference_data_source_description: S3ReferenceDataSourceDescription,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ReferenceDataSourceUpdate {
#[serde(rename = "ReferenceId")]
pub reference_id: String,
#[serde(rename = "ReferenceSchemaUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference_schema_update: Option<SourceSchema>,
#[serde(rename = "S3ReferenceDataSourceUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_reference_data_source_update: Option<S3ReferenceDataSourceUpdate>,
#[serde(rename = "TableNameUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_name_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct S3Configuration {
#[serde(rename = "BucketARN")]
pub bucket_arn: String,
#[serde(rename = "FileKey")]
pub file_key: String,
#[serde(rename = "RoleARN")]
pub role_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct S3ReferenceDataSource {
#[serde(rename = "BucketARN")]
pub bucket_arn: String,
#[serde(rename = "FileKey")]
pub file_key: String,
#[serde(rename = "ReferenceRoleARN")]
pub reference_role_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct S3ReferenceDataSourceDescription {
#[serde(rename = "BucketARN")]
pub bucket_arn: String,
#[serde(rename = "FileKey")]
pub file_key: String,
#[serde(rename = "ReferenceRoleARN")]
pub reference_role_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct S3ReferenceDataSourceUpdate {
#[serde(rename = "BucketARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket_arn_update: Option<String>,
#[serde(rename = "FileKeyUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_key_update: Option<String>,
#[serde(rename = "ReferenceRoleARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference_role_arn_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SourceSchema {
#[serde(rename = "RecordColumns")]
pub record_columns: Vec<RecordColumn>,
#[serde(rename = "RecordEncoding")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_encoding: Option<String>,
#[serde(rename = "RecordFormat")]
pub record_format: RecordFormat,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartApplicationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "InputConfigurations")]
pub input_configurations: Vec<InputConfiguration>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StartApplicationResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StopApplicationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StopApplicationResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateApplicationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "ApplicationUpdate")]
pub application_update: ApplicationUpdate,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateApplicationResponse {}
#[derive(Debug, PartialEq)]
pub enum AddApplicationCloudWatchLoggingOptionError {
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AddApplicationCloudWatchLoggingOptionError {
pub fn from_response(res: BufferedHttpResponse) -> AddApplicationCloudWatchLoggingOptionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return AddApplicationCloudWatchLoggingOptionError::ConcurrentModification(
String::from(error_message),
)
}
"InvalidArgumentException" => {
return AddApplicationCloudWatchLoggingOptionError::InvalidArgument(
String::from(error_message),
)
}
"ResourceInUseException" => {
return AddApplicationCloudWatchLoggingOptionError::ResourceInUse(String::from(
error_message,
))
}
"ResourceNotFoundException" => {
return AddApplicationCloudWatchLoggingOptionError::ResourceNotFound(
String::from(error_message),
)
}
"ValidationException" => {
return AddApplicationCloudWatchLoggingOptionError::Validation(
error_message.to_string(),
)
}
_ => {}
}
}
return AddApplicationCloudWatchLoggingOptionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AddApplicationCloudWatchLoggingOptionError {
fn from(err: serde_json::error::Error) -> AddApplicationCloudWatchLoggingOptionError {
AddApplicationCloudWatchLoggingOptionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AddApplicationCloudWatchLoggingOptionError {
fn from(err: CredentialsError) -> AddApplicationCloudWatchLoggingOptionError {
AddApplicationCloudWatchLoggingOptionError::Credentials(err)
}
}
impl From<HttpDispatchError> for AddApplicationCloudWatchLoggingOptionError {
fn from(err: HttpDispatchError) -> AddApplicationCloudWatchLoggingOptionError {
AddApplicationCloudWatchLoggingOptionError::HttpDispatch(err)
}
}
impl From<io::Error> for AddApplicationCloudWatchLoggingOptionError {
fn from(err: io::Error) -> AddApplicationCloudWatchLoggingOptionError {
AddApplicationCloudWatchLoggingOptionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AddApplicationCloudWatchLoggingOptionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AddApplicationCloudWatchLoggingOptionError {
fn description(&self) -> &str {
match *self {
AddApplicationCloudWatchLoggingOptionError::ConcurrentModification(ref cause) => cause,
AddApplicationCloudWatchLoggingOptionError::InvalidArgument(ref cause) => cause,
AddApplicationCloudWatchLoggingOptionError::ResourceInUse(ref cause) => cause,
AddApplicationCloudWatchLoggingOptionError::ResourceNotFound(ref cause) => cause,
AddApplicationCloudWatchLoggingOptionError::Validation(ref cause) => cause,
AddApplicationCloudWatchLoggingOptionError::Credentials(ref err) => err.description(),
AddApplicationCloudWatchLoggingOptionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AddApplicationCloudWatchLoggingOptionError::ParseError(ref cause) => cause,
AddApplicationCloudWatchLoggingOptionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AddApplicationInputError {
CodeValidation(String),
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AddApplicationInputError {
pub fn from_response(res: BufferedHttpResponse) -> AddApplicationInputError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"CodeValidationException" => {
return AddApplicationInputError::CodeValidation(String::from(error_message))
}
"ConcurrentModificationException" => {
return AddApplicationInputError::ConcurrentModification(String::from(
error_message,
))
}
"InvalidArgumentException" => {
return AddApplicationInputError::InvalidArgument(String::from(error_message))
}
"ResourceInUseException" => {
return AddApplicationInputError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return AddApplicationInputError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return AddApplicationInputError::Validation(error_message.to_string())
}
_ => {}
}
}
return AddApplicationInputError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AddApplicationInputError {
fn from(err: serde_json::error::Error) -> AddApplicationInputError {
AddApplicationInputError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AddApplicationInputError {
fn from(err: CredentialsError) -> AddApplicationInputError {
AddApplicationInputError::Credentials(err)
}
}
impl From<HttpDispatchError> for AddApplicationInputError {
fn from(err: HttpDispatchError) -> AddApplicationInputError {
AddApplicationInputError::HttpDispatch(err)
}
}
impl From<io::Error> for AddApplicationInputError {
fn from(err: io::Error) -> AddApplicationInputError {
AddApplicationInputError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AddApplicationInputError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AddApplicationInputError {
fn description(&self) -> &str {
match *self {
AddApplicationInputError::CodeValidation(ref cause) => cause,
AddApplicationInputError::ConcurrentModification(ref cause) => cause,
AddApplicationInputError::InvalidArgument(ref cause) => cause,
AddApplicationInputError::ResourceInUse(ref cause) => cause,
AddApplicationInputError::ResourceNotFound(ref cause) => cause,
AddApplicationInputError::Validation(ref cause) => cause,
AddApplicationInputError::Credentials(ref err) => err.description(),
AddApplicationInputError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AddApplicationInputError::ParseError(ref cause) => cause,
AddApplicationInputError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AddApplicationInputProcessingConfigurationError {
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AddApplicationInputProcessingConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> AddApplicationInputProcessingConfigurationError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return AddApplicationInputProcessingConfigurationError::ConcurrentModification(
String::from(error_message),
)
}
"InvalidArgumentException" => {
return AddApplicationInputProcessingConfigurationError::InvalidArgument(
String::from(error_message),
)
}
"ResourceInUseException" => {
return AddApplicationInputProcessingConfigurationError::ResourceInUse(
String::from(error_message),
)
}
"ResourceNotFoundException" => {
return AddApplicationInputProcessingConfigurationError::ResourceNotFound(
String::from(error_message),
)
}
"ValidationException" => {
return AddApplicationInputProcessingConfigurationError::Validation(
error_message.to_string(),
)
}
_ => {}
}
}
return AddApplicationInputProcessingConfigurationError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AddApplicationInputProcessingConfigurationError {
fn from(err: serde_json::error::Error) -> AddApplicationInputProcessingConfigurationError {
AddApplicationInputProcessingConfigurationError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AddApplicationInputProcessingConfigurationError {
fn from(err: CredentialsError) -> AddApplicationInputProcessingConfigurationError {
AddApplicationInputProcessingConfigurationError::Credentials(err)
}
}
impl From<HttpDispatchError> for AddApplicationInputProcessingConfigurationError {
fn from(err: HttpDispatchError) -> AddApplicationInputProcessingConfigurationError {
AddApplicationInputProcessingConfigurationError::HttpDispatch(err)
}
}
impl From<io::Error> for AddApplicationInputProcessingConfigurationError {
fn from(err: io::Error) -> AddApplicationInputProcessingConfigurationError {
AddApplicationInputProcessingConfigurationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AddApplicationInputProcessingConfigurationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AddApplicationInputProcessingConfigurationError {
fn description(&self) -> &str {
match *self {
AddApplicationInputProcessingConfigurationError::ConcurrentModification(ref cause) => {
cause
}
AddApplicationInputProcessingConfigurationError::InvalidArgument(ref cause) => cause,
AddApplicationInputProcessingConfigurationError::ResourceInUse(ref cause) => cause,
AddApplicationInputProcessingConfigurationError::ResourceNotFound(ref cause) => cause,
AddApplicationInputProcessingConfigurationError::Validation(ref cause) => cause,
AddApplicationInputProcessingConfigurationError::Credentials(ref err) => {
err.description()
}
AddApplicationInputProcessingConfigurationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AddApplicationInputProcessingConfigurationError::ParseError(ref cause) => cause,
AddApplicationInputProcessingConfigurationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AddApplicationOutputError {
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AddApplicationOutputError {
pub fn from_response(res: BufferedHttpResponse) -> AddApplicationOutputError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return AddApplicationOutputError::ConcurrentModification(String::from(
error_message,
))
}
"InvalidArgumentException" => {
return AddApplicationOutputError::InvalidArgument(String::from(error_message))
}
"ResourceInUseException" => {
return AddApplicationOutputError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return AddApplicationOutputError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return AddApplicationOutputError::Validation(error_message.to_string())
}
_ => {}
}
}
return AddApplicationOutputError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AddApplicationOutputError {
fn from(err: serde_json::error::Error) -> AddApplicationOutputError {
AddApplicationOutputError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AddApplicationOutputError {
fn from(err: CredentialsError) -> AddApplicationOutputError {
AddApplicationOutputError::Credentials(err)
}
}
impl From<HttpDispatchError> for AddApplicationOutputError {
fn from(err: HttpDispatchError) -> AddApplicationOutputError {
AddApplicationOutputError::HttpDispatch(err)
}
}
impl From<io::Error> for AddApplicationOutputError {
fn from(err: io::Error) -> AddApplicationOutputError {
AddApplicationOutputError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AddApplicationOutputError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AddApplicationOutputError {
fn description(&self) -> &str {
match *self {
AddApplicationOutputError::ConcurrentModification(ref cause) => cause,
AddApplicationOutputError::InvalidArgument(ref cause) => cause,
AddApplicationOutputError::ResourceInUse(ref cause) => cause,
AddApplicationOutputError::ResourceNotFound(ref cause) => cause,
AddApplicationOutputError::Validation(ref cause) => cause,
AddApplicationOutputError::Credentials(ref err) => err.description(),
AddApplicationOutputError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AddApplicationOutputError::ParseError(ref cause) => cause,
AddApplicationOutputError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AddApplicationReferenceDataSourceError {
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AddApplicationReferenceDataSourceError {
pub fn from_response(res: BufferedHttpResponse) -> AddApplicationReferenceDataSourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return AddApplicationReferenceDataSourceError::ConcurrentModification(
String::from(error_message),
)
}
"InvalidArgumentException" => {
return AddApplicationReferenceDataSourceError::InvalidArgument(String::from(
error_message,
))
}
"ResourceInUseException" => {
return AddApplicationReferenceDataSourceError::ResourceInUse(String::from(
error_message,
))
}
"ResourceNotFoundException" => {
return AddApplicationReferenceDataSourceError::ResourceNotFound(String::from(
error_message,
))
}
"ValidationException" => {
return AddApplicationReferenceDataSourceError::Validation(
error_message.to_string(),
)
}
_ => {}
}
}
return AddApplicationReferenceDataSourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AddApplicationReferenceDataSourceError {
fn from(err: serde_json::error::Error) -> AddApplicationReferenceDataSourceError {
AddApplicationReferenceDataSourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AddApplicationReferenceDataSourceError {
fn from(err: CredentialsError) -> AddApplicationReferenceDataSourceError {
AddApplicationReferenceDataSourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for AddApplicationReferenceDataSourceError {
fn from(err: HttpDispatchError) -> AddApplicationReferenceDataSourceError {
AddApplicationReferenceDataSourceError::HttpDispatch(err)
}
}
impl From<io::Error> for AddApplicationReferenceDataSourceError {
fn from(err: io::Error) -> AddApplicationReferenceDataSourceError {
AddApplicationReferenceDataSourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AddApplicationReferenceDataSourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AddApplicationReferenceDataSourceError {
fn description(&self) -> &str {
match *self {
AddApplicationReferenceDataSourceError::ConcurrentModification(ref cause) => cause,
AddApplicationReferenceDataSourceError::InvalidArgument(ref cause) => cause,
AddApplicationReferenceDataSourceError::ResourceInUse(ref cause) => cause,
AddApplicationReferenceDataSourceError::ResourceNotFound(ref cause) => cause,
AddApplicationReferenceDataSourceError::Validation(ref cause) => cause,
AddApplicationReferenceDataSourceError::Credentials(ref err) => err.description(),
AddApplicationReferenceDataSourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AddApplicationReferenceDataSourceError::ParseError(ref cause) => cause,
AddApplicationReferenceDataSourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateApplicationError {
CodeValidation(String),
InvalidArgument(String),
LimitExceeded(String),
ResourceInUse(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> CreateApplicationError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"CodeValidationException" => {
return CreateApplicationError::CodeValidation(String::from(error_message))
}
"InvalidArgumentException" => {
return CreateApplicationError::InvalidArgument(String::from(error_message))
}
"LimitExceededException" => {
return CreateApplicationError::LimitExceeded(String::from(error_message))
}
"ResourceInUseException" => {
return CreateApplicationError::ResourceInUse(String::from(error_message))
}
"ValidationException" => {
return CreateApplicationError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateApplicationError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateApplicationError {
fn from(err: serde_json::error::Error) -> CreateApplicationError {
CreateApplicationError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateApplicationError {
fn from(err: CredentialsError) -> CreateApplicationError {
CreateApplicationError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateApplicationError {
fn from(err: HttpDispatchError) -> CreateApplicationError {
CreateApplicationError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateApplicationError {
fn from(err: io::Error) -> CreateApplicationError {
CreateApplicationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateApplicationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateApplicationError {
fn description(&self) -> &str {
match *self {
CreateApplicationError::CodeValidation(ref cause) => cause,
CreateApplicationError::InvalidArgument(ref cause) => cause,
CreateApplicationError::LimitExceeded(ref cause) => cause,
CreateApplicationError::ResourceInUse(ref cause) => cause,
CreateApplicationError::Validation(ref cause) => cause,
CreateApplicationError::Credentials(ref err) => err.description(),
CreateApplicationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateApplicationError::ParseError(ref cause) => cause,
CreateApplicationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationError {
ConcurrentModification(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteApplicationError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return DeleteApplicationError::ConcurrentModification(String::from(
error_message,
))
}
"ResourceInUseException" => {
return DeleteApplicationError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return DeleteApplicationError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DeleteApplicationError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteApplicationError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteApplicationError {
fn from(err: serde_json::error::Error) -> DeleteApplicationError {
DeleteApplicationError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteApplicationError {
fn from(err: CredentialsError) -> DeleteApplicationError {
DeleteApplicationError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteApplicationError {
fn from(err: HttpDispatchError) -> DeleteApplicationError {
DeleteApplicationError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteApplicationError {
fn from(err: io::Error) -> DeleteApplicationError {
DeleteApplicationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteApplicationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteApplicationError {
fn description(&self) -> &str {
match *self {
DeleteApplicationError::ConcurrentModification(ref cause) => cause,
DeleteApplicationError::ResourceInUse(ref cause) => cause,
DeleteApplicationError::ResourceNotFound(ref cause) => cause,
DeleteApplicationError::Validation(ref cause) => cause,
DeleteApplicationError::Credentials(ref err) => err.description(),
DeleteApplicationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteApplicationError::ParseError(ref cause) => cause,
DeleteApplicationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationCloudWatchLoggingOptionError {
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteApplicationCloudWatchLoggingOptionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> DeleteApplicationCloudWatchLoggingOptionError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return DeleteApplicationCloudWatchLoggingOptionError::ConcurrentModification(
String::from(error_message),
)
}
"InvalidArgumentException" => {
return DeleteApplicationCloudWatchLoggingOptionError::InvalidArgument(
String::from(error_message),
)
}
"ResourceInUseException" => {
return DeleteApplicationCloudWatchLoggingOptionError::ResourceInUse(
String::from(error_message),
)
}
"ResourceNotFoundException" => {
return DeleteApplicationCloudWatchLoggingOptionError::ResourceNotFound(
String::from(error_message),
)
}
"ValidationException" => {
return DeleteApplicationCloudWatchLoggingOptionError::Validation(
error_message.to_string(),
)
}
_ => {}
}
}
return DeleteApplicationCloudWatchLoggingOptionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteApplicationCloudWatchLoggingOptionError {
fn from(err: serde_json::error::Error) -> DeleteApplicationCloudWatchLoggingOptionError {
DeleteApplicationCloudWatchLoggingOptionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteApplicationCloudWatchLoggingOptionError {
fn from(err: CredentialsError) -> DeleteApplicationCloudWatchLoggingOptionError {
DeleteApplicationCloudWatchLoggingOptionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteApplicationCloudWatchLoggingOptionError {
fn from(err: HttpDispatchError) -> DeleteApplicationCloudWatchLoggingOptionError {
DeleteApplicationCloudWatchLoggingOptionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteApplicationCloudWatchLoggingOptionError {
fn from(err: io::Error) -> DeleteApplicationCloudWatchLoggingOptionError {
DeleteApplicationCloudWatchLoggingOptionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteApplicationCloudWatchLoggingOptionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteApplicationCloudWatchLoggingOptionError {
fn description(&self) -> &str {
match *self {
DeleteApplicationCloudWatchLoggingOptionError::ConcurrentModification(ref cause) => {
cause
}
DeleteApplicationCloudWatchLoggingOptionError::InvalidArgument(ref cause) => cause,
DeleteApplicationCloudWatchLoggingOptionError::ResourceInUse(ref cause) => cause,
DeleteApplicationCloudWatchLoggingOptionError::ResourceNotFound(ref cause) => cause,
DeleteApplicationCloudWatchLoggingOptionError::Validation(ref cause) => cause,
DeleteApplicationCloudWatchLoggingOptionError::Credentials(ref err) => {
err.description()
}
DeleteApplicationCloudWatchLoggingOptionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteApplicationCloudWatchLoggingOptionError::ParseError(ref cause) => cause,
DeleteApplicationCloudWatchLoggingOptionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationInputProcessingConfigurationError {
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteApplicationInputProcessingConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> DeleteApplicationInputProcessingConfigurationError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => return DeleteApplicationInputProcessingConfigurationError::ConcurrentModification(String::from(error_message)),
"InvalidArgumentException" => return DeleteApplicationInputProcessingConfigurationError::InvalidArgument(String::from(error_message)),
"ResourceInUseException" => return DeleteApplicationInputProcessingConfigurationError::ResourceInUse(String::from(error_message)),
"ResourceNotFoundException" => return DeleteApplicationInputProcessingConfigurationError::ResourceNotFound(String::from(error_message)),
"ValidationException" => return DeleteApplicationInputProcessingConfigurationError::Validation(error_message.to_string()),
_ => {}
}
}
return DeleteApplicationInputProcessingConfigurationError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteApplicationInputProcessingConfigurationError {
fn from(err: serde_json::error::Error) -> DeleteApplicationInputProcessingConfigurationError {
DeleteApplicationInputProcessingConfigurationError::ParseError(
err.description().to_string(),
)
}
}
impl From<CredentialsError> for DeleteApplicationInputProcessingConfigurationError {
fn from(err: CredentialsError) -> DeleteApplicationInputProcessingConfigurationError {
DeleteApplicationInputProcessingConfigurationError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteApplicationInputProcessingConfigurationError {
fn from(err: HttpDispatchError) -> DeleteApplicationInputProcessingConfigurationError {
DeleteApplicationInputProcessingConfigurationError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteApplicationInputProcessingConfigurationError {
fn from(err: io::Error) -> DeleteApplicationInputProcessingConfigurationError {
DeleteApplicationInputProcessingConfigurationError::HttpDispatch(HttpDispatchError::from(
err,
))
}
}
impl fmt::Display for DeleteApplicationInputProcessingConfigurationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteApplicationInputProcessingConfigurationError {
fn description(&self) -> &str {
match *self {
DeleteApplicationInputProcessingConfigurationError::ConcurrentModification(
ref cause,
) => cause,
DeleteApplicationInputProcessingConfigurationError::InvalidArgument(ref cause) => cause,
DeleteApplicationInputProcessingConfigurationError::ResourceInUse(ref cause) => cause,
DeleteApplicationInputProcessingConfigurationError::ResourceNotFound(ref cause) => {
cause
}
DeleteApplicationInputProcessingConfigurationError::Validation(ref cause) => cause,
DeleteApplicationInputProcessingConfigurationError::Credentials(ref err) => {
err.description()
}
DeleteApplicationInputProcessingConfigurationError::HttpDispatch(
ref dispatch_error,
) => dispatch_error.description(),
DeleteApplicationInputProcessingConfigurationError::ParseError(ref cause) => cause,
DeleteApplicationInputProcessingConfigurationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationOutputError {
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteApplicationOutputError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteApplicationOutputError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return DeleteApplicationOutputError::ConcurrentModification(String::from(
error_message,
))
}
"InvalidArgumentException" => {
return DeleteApplicationOutputError::InvalidArgument(String::from(
error_message,
))
}
"ResourceInUseException" => {
return DeleteApplicationOutputError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return DeleteApplicationOutputError::ResourceNotFound(String::from(
error_message,
))
}
"ValidationException" => {
return DeleteApplicationOutputError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteApplicationOutputError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteApplicationOutputError {
fn from(err: serde_json::error::Error) -> DeleteApplicationOutputError {
DeleteApplicationOutputError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteApplicationOutputError {
fn from(err: CredentialsError) -> DeleteApplicationOutputError {
DeleteApplicationOutputError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteApplicationOutputError {
fn from(err: HttpDispatchError) -> DeleteApplicationOutputError {
DeleteApplicationOutputError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteApplicationOutputError {
fn from(err: io::Error) -> DeleteApplicationOutputError {
DeleteApplicationOutputError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteApplicationOutputError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteApplicationOutputError {
fn description(&self) -> &str {
match *self {
DeleteApplicationOutputError::ConcurrentModification(ref cause) => cause,
DeleteApplicationOutputError::InvalidArgument(ref cause) => cause,
DeleteApplicationOutputError::ResourceInUse(ref cause) => cause,
DeleteApplicationOutputError::ResourceNotFound(ref cause) => cause,
DeleteApplicationOutputError::Validation(ref cause) => cause,
DeleteApplicationOutputError::Credentials(ref err) => err.description(),
DeleteApplicationOutputError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteApplicationOutputError::ParseError(ref cause) => cause,
DeleteApplicationOutputError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationReferenceDataSourceError {
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteApplicationReferenceDataSourceError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteApplicationReferenceDataSourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ConcurrentModificationException" => {
return DeleteApplicationReferenceDataSourceError::ConcurrentModification(
String::from(error_message),
)
}
"InvalidArgumentException" => {
return DeleteApplicationReferenceDataSourceError::InvalidArgument(String::from(
error_message,
))
}
"ResourceInUseException" => {
return DeleteApplicationReferenceDataSourceError::ResourceInUse(String::from(
error_message,
))
}
"ResourceNotFoundException" => {
return DeleteApplicationReferenceDataSourceError::ResourceNotFound(
String::from(error_message),
)
}
"ValidationException" => {
return DeleteApplicationReferenceDataSourceError::Validation(
error_message.to_string(),
)
}
_ => {}
}
}
return DeleteApplicationReferenceDataSourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteApplicationReferenceDataSourceError {
fn from(err: serde_json::error::Error) -> DeleteApplicationReferenceDataSourceError {
DeleteApplicationReferenceDataSourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteApplicationReferenceDataSourceError {
fn from(err: CredentialsError) -> DeleteApplicationReferenceDataSourceError {
DeleteApplicationReferenceDataSourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteApplicationReferenceDataSourceError {
fn from(err: HttpDispatchError) -> DeleteApplicationReferenceDataSourceError {
DeleteApplicationReferenceDataSourceError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteApplicationReferenceDataSourceError {
fn from(err: io::Error) -> DeleteApplicationReferenceDataSourceError {
DeleteApplicationReferenceDataSourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteApplicationReferenceDataSourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteApplicationReferenceDataSourceError {
fn description(&self) -> &str {
match *self {
DeleteApplicationReferenceDataSourceError::ConcurrentModification(ref cause) => cause,
DeleteApplicationReferenceDataSourceError::InvalidArgument(ref cause) => cause,
DeleteApplicationReferenceDataSourceError::ResourceInUse(ref cause) => cause,
DeleteApplicationReferenceDataSourceError::ResourceNotFound(ref cause) => cause,
DeleteApplicationReferenceDataSourceError::Validation(ref cause) => cause,
DeleteApplicationReferenceDataSourceError::Credentials(ref err) => err.description(),
DeleteApplicationReferenceDataSourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteApplicationReferenceDataSourceError::ParseError(ref cause) => cause,
DeleteApplicationReferenceDataSourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeApplicationError {
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeApplicationError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceNotFoundException" => {
return DescribeApplicationError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return DescribeApplicationError::Validation(error_message.to_string())
}
_ => {}
}
}
return DescribeApplicationError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeApplicationError {
fn from(err: serde_json::error::Error) -> DescribeApplicationError {
DescribeApplicationError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeApplicationError {
fn from(err: CredentialsError) -> DescribeApplicationError {
DescribeApplicationError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeApplicationError {
fn from(err: HttpDispatchError) -> DescribeApplicationError {
DescribeApplicationError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeApplicationError {
fn from(err: io::Error) -> DescribeApplicationError {
DescribeApplicationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeApplicationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeApplicationError {
fn description(&self) -> &str {
match *self {
DescribeApplicationError::ResourceNotFound(ref cause) => cause,
DescribeApplicationError::Validation(ref cause) => cause,
DescribeApplicationError::Credentials(ref err) => err.description(),
DescribeApplicationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeApplicationError::ParseError(ref cause) => cause,
DescribeApplicationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DiscoverInputSchemaError {
InvalidArgument(String),
ResourceProvisionedThroughputExceeded(String),
ServiceUnavailable(String),
UnableToDetectSchema(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DiscoverInputSchemaError {
pub fn from_response(res: BufferedHttpResponse) -> DiscoverInputSchemaError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidArgumentException" => {
return DiscoverInputSchemaError::InvalidArgument(String::from(error_message))
}
"ResourceProvisionedThroughputExceededException" => {
return DiscoverInputSchemaError::ResourceProvisionedThroughputExceeded(
String::from(error_message),
)
}
"ServiceUnavailableException" => {
return DiscoverInputSchemaError::ServiceUnavailable(String::from(error_message))
}
"UnableToDetectSchemaException" => {
return DiscoverInputSchemaError::UnableToDetectSchema(String::from(
error_message,
))
}
"ValidationException" => {
return DiscoverInputSchemaError::Validation(error_message.to_string())
}
_ => {}
}
}
return DiscoverInputSchemaError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DiscoverInputSchemaError {
fn from(err: serde_json::error::Error) -> DiscoverInputSchemaError {
DiscoverInputSchemaError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DiscoverInputSchemaError {
fn from(err: CredentialsError) -> DiscoverInputSchemaError {
DiscoverInputSchemaError::Credentials(err)
}
}
impl From<HttpDispatchError> for DiscoverInputSchemaError {
fn from(err: HttpDispatchError) -> DiscoverInputSchemaError {
DiscoverInputSchemaError::HttpDispatch(err)
}
}
impl From<io::Error> for DiscoverInputSchemaError {
fn from(err: io::Error) -> DiscoverInputSchemaError {
DiscoverInputSchemaError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DiscoverInputSchemaError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DiscoverInputSchemaError {
fn description(&self) -> &str {
match *self {
DiscoverInputSchemaError::InvalidArgument(ref cause) => cause,
DiscoverInputSchemaError::ResourceProvisionedThroughputExceeded(ref cause) => cause,
DiscoverInputSchemaError::ServiceUnavailable(ref cause) => cause,
DiscoverInputSchemaError::UnableToDetectSchema(ref cause) => cause,
DiscoverInputSchemaError::Validation(ref cause) => cause,
DiscoverInputSchemaError::Credentials(ref err) => err.description(),
DiscoverInputSchemaError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DiscoverInputSchemaError::ParseError(ref cause) => cause,
DiscoverInputSchemaError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListApplicationsError {
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListApplicationsError {
pub fn from_response(res: BufferedHttpResponse) -> ListApplicationsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ValidationException" => {
return ListApplicationsError::Validation(error_message.to_string())
}
_ => {}
}
}
return ListApplicationsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListApplicationsError {
fn from(err: serde_json::error::Error) -> ListApplicationsError {
ListApplicationsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListApplicationsError {
fn from(err: CredentialsError) -> ListApplicationsError {
ListApplicationsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListApplicationsError {
fn from(err: HttpDispatchError) -> ListApplicationsError {
ListApplicationsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListApplicationsError {
fn from(err: io::Error) -> ListApplicationsError {
ListApplicationsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListApplicationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListApplicationsError {
fn description(&self) -> &str {
match *self {
ListApplicationsError::Validation(ref cause) => cause,
ListApplicationsError::Credentials(ref err) => err.description(),
ListApplicationsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListApplicationsError::ParseError(ref cause) => cause,
ListApplicationsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartApplicationError {
InvalidApplicationConfiguration(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> StartApplicationError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidApplicationConfigurationException" => {
return StartApplicationError::InvalidApplicationConfiguration(String::from(
error_message,
))
}
"InvalidArgumentException" => {
return StartApplicationError::InvalidArgument(String::from(error_message))
}
"ResourceInUseException" => {
return StartApplicationError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return StartApplicationError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return StartApplicationError::Validation(error_message.to_string())
}
_ => {}
}
}
return StartApplicationError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartApplicationError {
fn from(err: serde_json::error::Error) -> StartApplicationError {
StartApplicationError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartApplicationError {
fn from(err: CredentialsError) -> StartApplicationError {
StartApplicationError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartApplicationError {
fn from(err: HttpDispatchError) -> StartApplicationError {
StartApplicationError::HttpDispatch(err)
}
}
impl From<io::Error> for StartApplicationError {
fn from(err: io::Error) -> StartApplicationError {
StartApplicationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartApplicationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartApplicationError {
fn description(&self) -> &str {
match *self {
StartApplicationError::InvalidApplicationConfiguration(ref cause) => cause,
StartApplicationError::InvalidArgument(ref cause) => cause,
StartApplicationError::ResourceInUse(ref cause) => cause,
StartApplicationError::ResourceNotFound(ref cause) => cause,
StartApplicationError::Validation(ref cause) => cause,
StartApplicationError::Credentials(ref err) => err.description(),
StartApplicationError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StartApplicationError::ParseError(ref cause) => cause,
StartApplicationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StopApplicationError {
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StopApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> StopApplicationError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"ResourceInUseException" => {
return StopApplicationError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return StopApplicationError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return StopApplicationError::Validation(error_message.to_string())
}
_ => {}
}
}
return StopApplicationError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StopApplicationError {
fn from(err: serde_json::error::Error) -> StopApplicationError {
StopApplicationError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StopApplicationError {
fn from(err: CredentialsError) -> StopApplicationError {
StopApplicationError::Credentials(err)
}
}
impl From<HttpDispatchError> for StopApplicationError {
fn from(err: HttpDispatchError) -> StopApplicationError {
StopApplicationError::HttpDispatch(err)
}
}
impl From<io::Error> for StopApplicationError {
fn from(err: io::Error) -> StopApplicationError {
StopApplicationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StopApplicationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StopApplicationError {
fn description(&self) -> &str {
match *self {
StopApplicationError::ResourceInUse(ref cause) => cause,
StopApplicationError::ResourceNotFound(ref cause) => cause,
StopApplicationError::Validation(ref cause) => cause,
StopApplicationError::Credentials(ref err) => err.description(),
StopApplicationError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StopApplicationError::ParseError(ref cause) => cause,
StopApplicationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateApplicationError {
CodeValidation(String),
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateApplicationError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"CodeValidationException" => {
return UpdateApplicationError::CodeValidation(String::from(error_message))
}
"ConcurrentModificationException" => {
return UpdateApplicationError::ConcurrentModification(String::from(
error_message,
))
}
"InvalidArgumentException" => {
return UpdateApplicationError::InvalidArgument(String::from(error_message))
}
"ResourceInUseException" => {
return UpdateApplicationError::ResourceInUse(String::from(error_message))
}
"ResourceNotFoundException" => {
return UpdateApplicationError::ResourceNotFound(String::from(error_message))
}
"ValidationException" => {
return UpdateApplicationError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateApplicationError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateApplicationError {
fn from(err: serde_json::error::Error) -> UpdateApplicationError {
UpdateApplicationError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateApplicationError {
fn from(err: CredentialsError) -> UpdateApplicationError {
UpdateApplicationError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateApplicationError {
fn from(err: HttpDispatchError) -> UpdateApplicationError {
UpdateApplicationError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateApplicationError {
fn from(err: io::Error) -> UpdateApplicationError {
UpdateApplicationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateApplicationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateApplicationError {
fn description(&self) -> &str {
match *self {
UpdateApplicationError::CodeValidation(ref cause) => cause,
UpdateApplicationError::ConcurrentModification(ref cause) => cause,
UpdateApplicationError::InvalidArgument(ref cause) => cause,
UpdateApplicationError::ResourceInUse(ref cause) => cause,
UpdateApplicationError::ResourceNotFound(ref cause) => cause,
UpdateApplicationError::Validation(ref cause) => cause,
UpdateApplicationError::Credentials(ref err) => err.description(),
UpdateApplicationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateApplicationError::ParseError(ref cause) => cause,
UpdateApplicationError::Unknown(_) => "unknown error",
}
}
}
pub trait KinesisAnalytics {
fn add_application_cloud_watch_logging_option(
&self,
input: AddApplicationCloudWatchLoggingOptionRequest,
) -> RusotoFuture<
AddApplicationCloudWatchLoggingOptionResponse,
AddApplicationCloudWatchLoggingOptionError,
>;
fn add_application_input(
&self,
input: AddApplicationInputRequest,
) -> RusotoFuture<AddApplicationInputResponse, AddApplicationInputError>;
fn add_application_input_processing_configuration(
&self,
input: AddApplicationInputProcessingConfigurationRequest,
) -> RusotoFuture<
AddApplicationInputProcessingConfigurationResponse,
AddApplicationInputProcessingConfigurationError,
>;
fn add_application_output(
&self,
input: AddApplicationOutputRequest,
) -> RusotoFuture<AddApplicationOutputResponse, AddApplicationOutputError>;
fn add_application_reference_data_source(
&self,
input: AddApplicationReferenceDataSourceRequest,
) -> RusotoFuture<
AddApplicationReferenceDataSourceResponse,
AddApplicationReferenceDataSourceError,
>;
fn create_application(
&self,
input: CreateApplicationRequest,
) -> RusotoFuture<CreateApplicationResponse, CreateApplicationError>;
fn delete_application(
&self,
input: DeleteApplicationRequest,
) -> RusotoFuture<DeleteApplicationResponse, DeleteApplicationError>;
fn delete_application_cloud_watch_logging_option(
&self,
input: DeleteApplicationCloudWatchLoggingOptionRequest,
) -> RusotoFuture<
DeleteApplicationCloudWatchLoggingOptionResponse,
DeleteApplicationCloudWatchLoggingOptionError,
>;
fn delete_application_input_processing_configuration(
&self,
input: DeleteApplicationInputProcessingConfigurationRequest,
) -> RusotoFuture<
DeleteApplicationInputProcessingConfigurationResponse,
DeleteApplicationInputProcessingConfigurationError,
>;
fn delete_application_output(
&self,
input: DeleteApplicationOutputRequest,
) -> RusotoFuture<DeleteApplicationOutputResponse, DeleteApplicationOutputError>;
fn delete_application_reference_data_source(
&self,
input: DeleteApplicationReferenceDataSourceRequest,
) -> RusotoFuture<
DeleteApplicationReferenceDataSourceResponse,
DeleteApplicationReferenceDataSourceError,
>;
fn describe_application(
&self,
input: DescribeApplicationRequest,
) -> RusotoFuture<DescribeApplicationResponse, DescribeApplicationError>;
fn discover_input_schema(
&self,
input: DiscoverInputSchemaRequest,
) -> RusotoFuture<DiscoverInputSchemaResponse, DiscoverInputSchemaError>;
fn list_applications(
&self,
input: ListApplicationsRequest,
) -> RusotoFuture<ListApplicationsResponse, ListApplicationsError>;
fn start_application(
&self,
input: StartApplicationRequest,
) -> RusotoFuture<StartApplicationResponse, StartApplicationError>;
fn stop_application(
&self,
input: StopApplicationRequest,
) -> RusotoFuture<StopApplicationResponse, StopApplicationError>;
fn update_application(
&self,
input: UpdateApplicationRequest,
) -> RusotoFuture<UpdateApplicationResponse, UpdateApplicationError>;
}
pub struct KinesisAnalyticsClient {
client: Client,
region: region::Region,
}
impl KinesisAnalyticsClient {
pub fn new(region: region::Region) -> KinesisAnalyticsClient {
KinesisAnalyticsClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> KinesisAnalyticsClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
KinesisAnalyticsClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl KinesisAnalytics for KinesisAnalyticsClient {
fn add_application_cloud_watch_logging_option(
&self,
input: AddApplicationCloudWatchLoggingOptionRequest,
) -> RusotoFuture<
AddApplicationCloudWatchLoggingOptionResponse,
AddApplicationCloudWatchLoggingOptionError,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.AddApplicationCloudWatchLoggingOption",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<AddApplicationCloudWatchLoggingOptionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(AddApplicationCloudWatchLoggingOptionError::from_response(
response,
))
}))
}
})
}
fn add_application_input(
&self,
input: AddApplicationInputRequest,
) -> RusotoFuture<AddApplicationInputResponse, AddApplicationInputError> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.AddApplicationInput",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<AddApplicationInputResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(AddApplicationInputError::from_response(response))
}),
)
}
})
}
fn add_application_input_processing_configuration(
&self,
input: AddApplicationInputProcessingConfigurationRequest,
) -> RusotoFuture<
AddApplicationInputProcessingConfigurationResponse,
AddApplicationInputProcessingConfigurationError,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.AddApplicationInputProcessingConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<AddApplicationInputProcessingConfigurationResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(AddApplicationInputProcessingConfigurationError::from_response(response))
}))
}
})
}
fn add_application_output(
&self,
input: AddApplicationOutputRequest,
) -> RusotoFuture<AddApplicationOutputResponse, AddApplicationOutputError> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.AddApplicationOutput",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<AddApplicationOutputResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(AddApplicationOutputError::from_response(response))
}),
)
}
})
}
fn add_application_reference_data_source(
&self,
input: AddApplicationReferenceDataSourceRequest,
) -> RusotoFuture<
AddApplicationReferenceDataSourceResponse,
AddApplicationReferenceDataSourceError,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.AddApplicationReferenceDataSource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<AddApplicationReferenceDataSourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(AddApplicationReferenceDataSourceError::from_response(
response,
))
}))
}
})
}
fn create_application(
&self,
input: CreateApplicationRequest,
) -> RusotoFuture<CreateApplicationResponse, CreateApplicationError> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.CreateApplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateApplicationResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateApplicationError::from_response(response))),
)
}
})
}
fn delete_application(
&self,
input: DeleteApplicationRequest,
) -> RusotoFuture<DeleteApplicationResponse, DeleteApplicationError> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.DeleteApplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteApplicationResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteApplicationError::from_response(response))),
)
}
})
}
fn delete_application_cloud_watch_logging_option(
&self,
input: DeleteApplicationCloudWatchLoggingOptionRequest,
) -> RusotoFuture<
DeleteApplicationCloudWatchLoggingOptionResponse,
DeleteApplicationCloudWatchLoggingOptionError,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.DeleteApplicationCloudWatchLoggingOption",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteApplicationCloudWatchLoggingOptionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteApplicationCloudWatchLoggingOptionError::from_response(response))
}))
}
})
}
fn delete_application_input_processing_configuration(
&self,
input: DeleteApplicationInputProcessingConfigurationRequest,
) -> RusotoFuture<
DeleteApplicationInputProcessingConfigurationResponse,
DeleteApplicationInputProcessingConfigurationError,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.DeleteApplicationInputProcessingConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteApplicationInputProcessingConfigurationResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteApplicationInputProcessingConfigurationError::from_response(response))
}))
}
})
}
fn delete_application_output(
&self,
input: DeleteApplicationOutputRequest,
) -> RusotoFuture<DeleteApplicationOutputResponse, DeleteApplicationOutputError> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.DeleteApplicationOutput",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteApplicationOutputResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteApplicationOutputError::from_response(response))
}))
}
})
}
fn delete_application_reference_data_source(
&self,
input: DeleteApplicationReferenceDataSourceRequest,
) -> RusotoFuture<
DeleteApplicationReferenceDataSourceResponse,
DeleteApplicationReferenceDataSourceError,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.DeleteApplicationReferenceDataSource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteApplicationReferenceDataSourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteApplicationReferenceDataSourceError::from_response(
response,
))
}))
}
})
}
fn describe_application(
&self,
input: DescribeApplicationRequest,
) -> RusotoFuture<DescribeApplicationResponse, DescribeApplicationError> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.DescribeApplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeApplicationResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeApplicationError::from_response(response))
}),
)
}
})
}
fn discover_input_schema(
&self,
input: DiscoverInputSchemaRequest,
) -> RusotoFuture<DiscoverInputSchemaResponse, DiscoverInputSchemaError> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.DiscoverInputSchema",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DiscoverInputSchemaResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DiscoverInputSchemaError::from_response(response))
}),
)
}
})
}
fn list_applications(
&self,
input: ListApplicationsRequest,
) -> RusotoFuture<ListApplicationsResponse, ListApplicationsError> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "KinesisAnalytics_20150814.ListApplications");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListApplicationsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListApplicationsError::from_response(response))),
)
}
})
}
fn start_application(
&self,
input: StartApplicationRequest,
) -> RusotoFuture<StartApplicationResponse, StartApplicationError> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "KinesisAnalytics_20150814.StartApplication");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<StartApplicationResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StartApplicationError::from_response(response))),
)
}
})
}
fn stop_application(
&self,
input: StopApplicationRequest,
) -> RusotoFuture<StopApplicationResponse, StopApplicationError> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "KinesisAnalytics_20150814.StopApplication");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<StopApplicationResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StopApplicationError::from_response(response))),
)
}
})
}
fn update_application(
&self,
input: UpdateApplicationRequest,
) -> RusotoFuture<UpdateApplicationResponse, UpdateApplicationError> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20150814.UpdateApplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<UpdateApplicationResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateApplicationError::from_response(response))),
)
}
})
}
}
#[cfg(test)]
mod protocol_tests {}