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, Deserialize)]
pub struct Action {
#[serde(rename = "Arguments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arguments: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "NotificationProperty")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_property: Option<NotificationProperty>,
#[serde(rename = "Timeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct BatchCreatePartitionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "PartitionInputList")]
pub partition_input_list: Vec<PartitionInput>,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BatchCreatePartitionResponse {
#[serde(rename = "Errors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub errors: Option<Vec<PartitionError>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct BatchDeleteConnectionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "ConnectionNameList")]
pub connection_name_list: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BatchDeleteConnectionResponse {
#[serde(rename = "Errors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub errors: Option<::std::collections::HashMap<String, ErrorDetail>>,
#[serde(rename = "Succeeded")]
#[serde(skip_serializing_if = "Option::is_none")]
pub succeeded: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct BatchDeletePartitionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "PartitionsToDelete")]
pub partitions_to_delete: Vec<PartitionValueList>,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BatchDeletePartitionResponse {
#[serde(rename = "Errors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub errors: Option<Vec<PartitionError>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct BatchDeleteTableRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "TablesToDelete")]
pub tables_to_delete: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BatchDeleteTableResponse {
#[serde(rename = "Errors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub errors: Option<Vec<TableError>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct BatchDeleteTableVersionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "TableName")]
pub table_name: String,
#[serde(rename = "VersionIds")]
pub version_ids: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BatchDeleteTableVersionResponse {
#[serde(rename = "Errors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub errors: Option<Vec<TableVersionError>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct BatchGetPartitionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "PartitionsToGet")]
pub partitions_to_get: Vec<PartitionValueList>,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BatchGetPartitionResponse {
#[serde(rename = "Partitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub partitions: Option<Vec<Partition>>,
#[serde(rename = "UnprocessedKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unprocessed_keys: Option<Vec<PartitionValueList>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BatchStopJobRunError {
#[serde(rename = "ErrorDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_detail: Option<ErrorDetail>,
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "JobRunId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_run_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct BatchStopJobRunRequest {
#[serde(rename = "JobName")]
pub job_name: String,
#[serde(rename = "JobRunIds")]
pub job_run_ids: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BatchStopJobRunResponse {
#[serde(rename = "Errors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub errors: Option<Vec<BatchStopJobRunError>>,
#[serde(rename = "SuccessfulSubmissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub successful_submissions: Option<Vec<BatchStopJobRunSuccessfulSubmission>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct BatchStopJobRunSuccessfulSubmission {
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "JobRunId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_run_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CatalogEntry {
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CatalogImportStatus {
#[serde(rename = "ImportCompleted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_completed: Option<bool>,
#[serde(rename = "ImportTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_time: Option<f64>,
#[serde(rename = "ImportedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub imported_by: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Classifier {
#[serde(rename = "GrokClassifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grok_classifier: Option<GrokClassifier>,
#[serde(rename = "JsonClassifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub json_classifier: Option<JsonClassifier>,
#[serde(rename = "XMLClassifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub xml_classifier: Option<XMLClassifier>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CodeGenEdge {
#[serde(rename = "Source")]
pub source: String,
#[serde(rename = "Target")]
pub target: String,
#[serde(rename = "TargetParameter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_parameter: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CodeGenNode {
#[serde(rename = "Args")]
pub args: Vec<CodeGenNodeArg>,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "LineNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub line_number: Option<i64>,
#[serde(rename = "NodeType")]
pub node_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CodeGenNodeArg {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Param")]
#[serde(skip_serializing_if = "Option::is_none")]
pub param: Option<bool>,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Column {
#[serde(rename = "Comment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comment: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Condition {
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "LogicalOperator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logical_operator: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Connection {
#[serde(rename = "ConnectionProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_properties: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ConnectionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_type: Option<String>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LastUpdatedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_by: Option<String>,
#[serde(rename = "LastUpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<f64>,
#[serde(rename = "MatchCriteria")]
#[serde(skip_serializing_if = "Option::is_none")]
pub match_criteria: Option<Vec<String>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "PhysicalConnectionRequirements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub physical_connection_requirements: Option<PhysicalConnectionRequirements>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ConnectionInput {
#[serde(rename = "ConnectionProperties")]
pub connection_properties: ::std::collections::HashMap<String, String>,
#[serde(rename = "ConnectionType")]
pub connection_type: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "MatchCriteria")]
#[serde(skip_serializing_if = "Option::is_none")]
pub match_criteria: Option<Vec<String>>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "PhysicalConnectionRequirements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub physical_connection_requirements: Option<PhysicalConnectionRequirements>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConnectionsList {
#[serde(rename = "Connections")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connections: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Crawler {
#[serde(rename = "Classifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub classifiers: Option<Vec<String>>,
#[serde(rename = "Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<String>,
#[serde(rename = "CrawlElapsedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crawl_elapsed_time: Option<i64>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "DatabaseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database_name: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LastCrawl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_crawl: Option<LastCrawlInfo>,
#[serde(rename = "LastUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Role")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role: Option<String>,
#[serde(rename = "Schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<Schedule>,
#[serde(rename = "SchemaChangePolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_change_policy: Option<SchemaChangePolicy>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "TablePrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_prefix: Option<String>,
#[serde(rename = "Targets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub targets: Option<CrawlerTargets>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CrawlerMetrics {
#[serde(rename = "CrawlerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crawler_name: Option<String>,
#[serde(rename = "LastRuntimeSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_runtime_seconds: Option<f64>,
#[serde(rename = "MedianRuntimeSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub median_runtime_seconds: Option<f64>,
#[serde(rename = "StillEstimating")]
#[serde(skip_serializing_if = "Option::is_none")]
pub still_estimating: Option<bool>,
#[serde(rename = "TablesCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tables_created: Option<i64>,
#[serde(rename = "TablesDeleted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tables_deleted: Option<i64>,
#[serde(rename = "TablesUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tables_updated: Option<i64>,
#[serde(rename = "TimeLeftSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub time_left_seconds: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CrawlerTargets {
#[serde(rename = "DynamoDBTargets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamo_db_targets: Option<Vec<DynamoDBTarget>>,
#[serde(rename = "JdbcTargets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jdbc_targets: Option<Vec<JdbcTarget>>,
#[serde(rename = "S3Targets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_targets: Option<Vec<S3Target>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateClassifierRequest {
#[serde(rename = "GrokClassifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grok_classifier: Option<CreateGrokClassifierRequest>,
#[serde(rename = "JsonClassifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub json_classifier: Option<CreateJsonClassifierRequest>,
#[serde(rename = "XMLClassifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub xml_classifier: Option<CreateXMLClassifierRequest>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateClassifierResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateConnectionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "ConnectionInput")]
pub connection_input: ConnectionInput,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateConnectionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateCrawlerRequest {
#[serde(rename = "Classifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub classifiers: Option<Vec<String>>,
#[serde(rename = "Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Role")]
pub role: String,
#[serde(rename = "Schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<String>,
#[serde(rename = "SchemaChangePolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_change_policy: Option<SchemaChangePolicy>,
#[serde(rename = "TablePrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_prefix: Option<String>,
#[serde(rename = "Targets")]
pub targets: CrawlerTargets,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateCrawlerResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateDatabaseRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseInput")]
pub database_input: DatabaseInput,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateDatabaseResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateDevEndpointRequest {
#[serde(rename = "EndpointName")]
pub endpoint_name: String,
#[serde(rename = "ExtraJarsS3Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extra_jars_s3_path: Option<String>,
#[serde(rename = "ExtraPythonLibsS3Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extra_python_libs_s3_path: Option<String>,
#[serde(rename = "NumberOfNodes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_nodes: Option<i64>,
#[serde(rename = "PublicKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_key: Option<String>,
#[serde(rename = "PublicKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_keys: Option<Vec<String>>,
#[serde(rename = "RoleArn")]
pub role_arn: String,
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "SubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateDevEndpointResponse {
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "CreatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_timestamp: Option<f64>,
#[serde(rename = "EndpointName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_name: Option<String>,
#[serde(rename = "ExtraJarsS3Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extra_jars_s3_path: Option<String>,
#[serde(rename = "ExtraPythonLibsS3Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extra_python_libs_s3_path: Option<String>,
#[serde(rename = "FailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "NumberOfNodes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_nodes: Option<i64>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "SubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
#[serde(rename = "VpcId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
#[serde(rename = "YarnEndpointAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub yarn_endpoint_address: Option<String>,
#[serde(rename = "ZeppelinRemoteSparkInterpreterPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub zeppelin_remote_spark_interpreter_port: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateGrokClassifierRequest {
#[serde(rename = "Classification")]
pub classification: String,
#[serde(rename = "CustomPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_patterns: Option<String>,
#[serde(rename = "GrokPattern")]
pub grok_pattern: String,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateJobRequest {
#[serde(rename = "AllocatedCapacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allocated_capacity: Option<i64>,
#[serde(rename = "Command")]
pub command: JobCommand,
#[serde(rename = "Connections")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connections: Option<ConnectionsList>,
#[serde(rename = "DefaultArguments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_arguments: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ExecutionProperty")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution_property: Option<ExecutionProperty>,
#[serde(rename = "LogUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_uri: Option<String>,
#[serde(rename = "MaxRetries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_retries: Option<i64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "NotificationProperty")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_property: Option<NotificationProperty>,
#[serde(rename = "Role")]
pub role: String,
#[serde(rename = "Timeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateJobResponse {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateJsonClassifierRequest {
#[serde(rename = "JsonPath")]
pub json_path: String,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreatePartitionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "PartitionInput")]
pub partition_input: PartitionInput,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreatePartitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateScriptRequest {
#[serde(rename = "DagEdges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dag_edges: Option<Vec<CodeGenEdge>>,
#[serde(rename = "DagNodes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dag_nodes: Option<Vec<CodeGenNode>>,
#[serde(rename = "Language")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateScriptResponse {
#[serde(rename = "PythonScript")]
#[serde(skip_serializing_if = "Option::is_none")]
pub python_script: Option<String>,
#[serde(rename = "ScalaCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scala_code: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateTableRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "TableInput")]
pub table_input: TableInput,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateTableResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateTriggerRequest {
#[serde(rename = "Actions")]
pub actions: Vec<Action>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Predicate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub predicate: Option<Predicate>,
#[serde(rename = "Schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<String>,
#[serde(rename = "StartOnCreation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_on_creation: Option<bool>,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateTriggerResponse {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateUserDefinedFunctionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "FunctionInput")]
pub function_input: UserDefinedFunctionInput,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateUserDefinedFunctionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateXMLClassifierRequest {
#[serde(rename = "Classification")]
pub classification: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RowTag")]
#[serde(skip_serializing_if = "Option::is_none")]
pub row_tag: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Database {
#[serde(rename = "CreateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LocationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_uri: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DatabaseInput {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LocationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_uri: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteClassifierRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteClassifierResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteConnectionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "ConnectionName")]
pub connection_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteConnectionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteCrawlerRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteCrawlerResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteDatabaseRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteDatabaseResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteDevEndpointRequest {
#[serde(rename = "EndpointName")]
pub endpoint_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteDevEndpointResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteJobRequest {
#[serde(rename = "JobName")]
pub job_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteJobResponse {
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeletePartitionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "PartitionValues")]
pub partition_values: Vec<String>,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeletePartitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteTableRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteTableResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteTableVersionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "TableName")]
pub table_name: String,
#[serde(rename = "VersionId")]
pub version_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteTableVersionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteTriggerRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteTriggerResponse {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteUserDefinedFunctionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "FunctionName")]
pub function_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteUserDefinedFunctionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DevEndpoint {
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "CreatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_timestamp: Option<f64>,
#[serde(rename = "EndpointName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_name: Option<String>,
#[serde(rename = "ExtraJarsS3Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extra_jars_s3_path: Option<String>,
#[serde(rename = "ExtraPythonLibsS3Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extra_python_libs_s3_path: Option<String>,
#[serde(rename = "FailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "LastModifiedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_timestamp: Option<f64>,
#[serde(rename = "LastUpdateStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_status: Option<String>,
#[serde(rename = "NumberOfNodes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_nodes: Option<i64>,
#[serde(rename = "PrivateAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_address: Option<String>,
#[serde(rename = "PublicAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_address: Option<String>,
#[serde(rename = "PublicKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_key: Option<String>,
#[serde(rename = "PublicKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_keys: Option<Vec<String>>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "SubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
#[serde(rename = "VpcId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
#[serde(rename = "YarnEndpointAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub yarn_endpoint_address: Option<String>,
#[serde(rename = "ZeppelinRemoteSparkInterpreterPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub zeppelin_remote_spark_interpreter_port: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DevEndpointCustomLibraries {
#[serde(rename = "ExtraJarsS3Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extra_jars_s3_path: Option<String>,
#[serde(rename = "ExtraPythonLibsS3Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub extra_python_libs_s3_path: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DynamoDBTarget {
#[serde(rename = "Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ErrorDetail {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ExecutionProperty {
#[serde(rename = "MaxConcurrentRuns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_concurrent_runs: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetCatalogImportStatusRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetCatalogImportStatusResponse {
#[serde(rename = "ImportStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_status: Option<CatalogImportStatus>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetClassifierRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetClassifierResponse {
#[serde(rename = "Classifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub classifier: Option<Classifier>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetClassifiersRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetClassifiersResponse {
#[serde(rename = "Classifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub classifiers: Option<Vec<Classifier>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetConnectionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetConnectionResponse {
#[serde(rename = "Connection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection: Option<Connection>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetConnectionsFilter {
#[serde(rename = "ConnectionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_type: Option<String>,
#[serde(rename = "MatchCriteria")]
#[serde(skip_serializing_if = "Option::is_none")]
pub match_criteria: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetConnectionsRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "Filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<GetConnectionsFilter>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetConnectionsResponse {
#[serde(rename = "ConnectionList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_list: Option<Vec<Connection>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetCrawlerMetricsRequest {
#[serde(rename = "CrawlerNameList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crawler_name_list: Option<Vec<String>>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetCrawlerMetricsResponse {
#[serde(rename = "CrawlerMetricsList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crawler_metrics_list: Option<Vec<CrawlerMetrics>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetCrawlerRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetCrawlerResponse {
#[serde(rename = "Crawler")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crawler: Option<Crawler>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetCrawlersRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetCrawlersResponse {
#[serde(rename = "Crawlers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crawlers: Option<Vec<Crawler>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetDatabaseRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetDatabaseResponse {
#[serde(rename = "Database")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database: Option<Database>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetDatabasesRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetDatabasesResponse {
#[serde(rename = "DatabaseList")]
pub database_list: Vec<Database>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetDataflowGraphRequest {
#[serde(rename = "PythonScript")]
#[serde(skip_serializing_if = "Option::is_none")]
pub python_script: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetDataflowGraphResponse {
#[serde(rename = "DagEdges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dag_edges: Option<Vec<CodeGenEdge>>,
#[serde(rename = "DagNodes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dag_nodes: Option<Vec<CodeGenNode>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetDevEndpointRequest {
#[serde(rename = "EndpointName")]
pub endpoint_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetDevEndpointResponse {
#[serde(rename = "DevEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dev_endpoint: Option<DevEndpoint>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetDevEndpointsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetDevEndpointsResponse {
#[serde(rename = "DevEndpoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dev_endpoints: Option<Vec<DevEndpoint>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetJobRequest {
#[serde(rename = "JobName")]
pub job_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetJobResponse {
#[serde(rename = "Job")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job: Option<Job>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetJobRunRequest {
#[serde(rename = "JobName")]
pub job_name: String,
#[serde(rename = "PredecessorsIncluded")]
#[serde(skip_serializing_if = "Option::is_none")]
pub predecessors_included: Option<bool>,
#[serde(rename = "RunId")]
pub run_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetJobRunResponse {
#[serde(rename = "JobRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_run: Option<JobRun>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetJobRunsRequest {
#[serde(rename = "JobName")]
pub job_name: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetJobRunsResponse {
#[serde(rename = "JobRuns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_runs: Option<Vec<JobRun>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetJobsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetJobsResponse {
#[serde(rename = "Jobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jobs: Option<Vec<Job>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetMappingRequest {
#[serde(rename = "Location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<Location>,
#[serde(rename = "Sinks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sinks: Option<Vec<CatalogEntry>>,
#[serde(rename = "Source")]
pub source: CatalogEntry,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetMappingResponse {
#[serde(rename = "Mapping")]
pub mapping: Vec<MappingEntry>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetPartitionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "PartitionValues")]
pub partition_values: Vec<String>,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetPartitionResponse {
#[serde(rename = "Partition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub partition: Option<Partition>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetPartitionsRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "Expression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expression: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Segment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub segment: Option<Segment>,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetPartitionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Partitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub partitions: Option<Vec<Partition>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetPlanRequest {
#[serde(rename = "Language")]
#[serde(skip_serializing_if = "Option::is_none")]
pub language: Option<String>,
#[serde(rename = "Location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<Location>,
#[serde(rename = "Mapping")]
pub mapping: Vec<MappingEntry>,
#[serde(rename = "Sinks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sinks: Option<Vec<CatalogEntry>>,
#[serde(rename = "Source")]
pub source: CatalogEntry,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetPlanResponse {
#[serde(rename = "PythonScript")]
#[serde(skip_serializing_if = "Option::is_none")]
pub python_script: Option<String>,
#[serde(rename = "ScalaCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scala_code: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetTableRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetTableResponse {
#[serde(rename = "Table")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table: Option<Table>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetTableVersionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "TableName")]
pub table_name: String,
#[serde(rename = "VersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetTableVersionResponse {
#[serde(rename = "TableVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_version: Option<TableVersion>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetTableVersionsRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetTableVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "TableVersions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_versions: Option<Vec<TableVersion>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetTablesRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "Expression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expression: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetTablesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "TableList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_list: Option<Vec<Table>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetTriggerRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetTriggerResponse {
#[serde(rename = "Trigger")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trigger: Option<Trigger>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetTriggersRequest {
#[serde(rename = "DependentJobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dependent_job_name: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetTriggersResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Triggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub triggers: Option<Vec<Trigger>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetUserDefinedFunctionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "FunctionName")]
pub function_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetUserDefinedFunctionResponse {
#[serde(rename = "UserDefinedFunction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_defined_function: Option<UserDefinedFunction>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetUserDefinedFunctionsRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Pattern")]
pub pattern: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetUserDefinedFunctionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "UserDefinedFunctions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_defined_functions: Option<Vec<UserDefinedFunction>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GrokClassifier {
#[serde(rename = "Classification")]
pub classification: String,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "CustomPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_patterns: Option<String>,
#[serde(rename = "GrokPattern")]
pub grok_pattern: String,
#[serde(rename = "LastUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated: Option<f64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ImportCatalogToGlueRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ImportCatalogToGlueResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct JdbcTarget {
#[serde(rename = "ConnectionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_name: Option<String>,
#[serde(rename = "Exclusions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclusions: Option<Vec<String>>,
#[serde(rename = "Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Job {
#[serde(rename = "AllocatedCapacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allocated_capacity: Option<i64>,
#[serde(rename = "Command")]
#[serde(skip_serializing_if = "Option::is_none")]
pub command: Option<JobCommand>,
#[serde(rename = "Connections")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connections: Option<ConnectionsList>,
#[serde(rename = "CreatedOn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_on: Option<f64>,
#[serde(rename = "DefaultArguments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_arguments: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ExecutionProperty")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution_property: Option<ExecutionProperty>,
#[serde(rename = "LastModifiedOn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_on: Option<f64>,
#[serde(rename = "LogUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_uri: Option<String>,
#[serde(rename = "MaxRetries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_retries: Option<i64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "NotificationProperty")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_property: Option<NotificationProperty>,
#[serde(rename = "Role")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role: Option<String>,
#[serde(rename = "Timeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct JobBookmarkEntry {
#[serde(rename = "Attempt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attempt: Option<i64>,
#[serde(rename = "JobBookmark")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_bookmark: Option<String>,
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "Run")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run: Option<i64>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct JobCommand {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ScriptLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub script_location: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct JobRun {
#[serde(rename = "AllocatedCapacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allocated_capacity: Option<i64>,
#[serde(rename = "Arguments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arguments: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Attempt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attempt: Option<i64>,
#[serde(rename = "CompletedOn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completed_on: Option<f64>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "ExecutionTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution_time: Option<i64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "JobRunState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_run_state: Option<String>,
#[serde(rename = "LastModifiedOn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_on: Option<f64>,
#[serde(rename = "NotificationProperty")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_property: Option<NotificationProperty>,
#[serde(rename = "PredecessorRuns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub predecessor_runs: Option<Vec<Predecessor>>,
#[serde(rename = "PreviousRunId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub previous_run_id: Option<String>,
#[serde(rename = "StartedOn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub started_on: Option<f64>,
#[serde(rename = "Timeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<i64>,
#[serde(rename = "TriggerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trigger_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct JobUpdate {
#[serde(rename = "AllocatedCapacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allocated_capacity: Option<i64>,
#[serde(rename = "Command")]
#[serde(skip_serializing_if = "Option::is_none")]
pub command: Option<JobCommand>,
#[serde(rename = "Connections")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connections: Option<ConnectionsList>,
#[serde(rename = "DefaultArguments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_arguments: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ExecutionProperty")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution_property: Option<ExecutionProperty>,
#[serde(rename = "LogUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_uri: Option<String>,
#[serde(rename = "MaxRetries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_retries: Option<i64>,
#[serde(rename = "NotificationProperty")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_property: Option<NotificationProperty>,
#[serde(rename = "Role")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role: Option<String>,
#[serde(rename = "Timeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct JsonClassifier {
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "JsonPath")]
pub json_path: String,
#[serde(rename = "LastUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated: Option<f64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct LastCrawlInfo {
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "LogGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_group: Option<String>,
#[serde(rename = "LogStream")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_stream: Option<String>,
#[serde(rename = "MessagePrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message_prefix: Option<String>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct Location {
#[serde(rename = "DynamoDB")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamo_db: Option<Vec<CodeGenNodeArg>>,
#[serde(rename = "Jdbc")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jdbc: Option<Vec<CodeGenNodeArg>>,
#[serde(rename = "S3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3: Option<Vec<CodeGenNodeArg>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MappingEntry {
#[serde(rename = "SourcePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_path: Option<String>,
#[serde(rename = "SourceTable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_table: Option<String>,
#[serde(rename = "SourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_type: Option<String>,
#[serde(rename = "TargetPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_path: Option<String>,
#[serde(rename = "TargetTable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_table: Option<String>,
#[serde(rename = "TargetType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NotificationProperty {
#[serde(rename = "NotifyDelayAfter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notify_delay_after: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Order {
#[serde(rename = "Column")]
pub column: String,
#[serde(rename = "SortOrder")]
pub sort_order: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Partition {
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "DatabaseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database_name: Option<String>,
#[serde(rename = "LastAccessTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_access_time: Option<f64>,
#[serde(rename = "LastAnalyzedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_analyzed_time: Option<f64>,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "StorageDescriptor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage_descriptor: Option<StorageDescriptor>,
#[serde(rename = "TableName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_name: Option<String>,
#[serde(rename = "Values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct PartitionError {
#[serde(rename = "ErrorDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_detail: Option<ErrorDetail>,
#[serde(rename = "PartitionValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub partition_values: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct PartitionInput {
#[serde(rename = "LastAccessTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_access_time: Option<f64>,
#[serde(rename = "LastAnalyzedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_analyzed_time: Option<f64>,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "StorageDescriptor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage_descriptor: Option<StorageDescriptor>,
#[serde(rename = "Values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PartitionValueList {
#[serde(rename = "Values")]
pub values: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PhysicalConnectionRequirements {
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "SecurityGroupIdList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_id_list: Option<Vec<String>>,
#[serde(rename = "SubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Predecessor {
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "RunId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Predicate {
#[serde(rename = "Conditions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conditions: Option<Vec<Condition>>,
#[serde(rename = "Logical")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logical: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ResetJobBookmarkRequest {
#[serde(rename = "JobName")]
pub job_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ResetJobBookmarkResponse {
#[serde(rename = "JobBookmarkEntry")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_bookmark_entry: Option<JobBookmarkEntry>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ResourceUri {
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "Uri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uri: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct S3Target {
#[serde(rename = "Exclusions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclusions: Option<Vec<String>>,
#[serde(rename = "Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Schedule {
#[serde(rename = "ScheduleExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule_expression: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SchemaChangePolicy {
#[serde(rename = "DeleteBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_behavior: Option<String>,
#[serde(rename = "UpdateBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_behavior: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct Segment {
#[serde(rename = "SegmentNumber")]
pub segment_number: i64,
#[serde(rename = "TotalSegments")]
pub total_segments: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SerDeInfo {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "SerializationLibrary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub serialization_library: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SkewedInfo {
#[serde(rename = "SkewedColumnNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skewed_column_names: Option<Vec<String>>,
#[serde(rename = "SkewedColumnValueLocationMaps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skewed_column_value_location_maps: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "SkewedColumnValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skewed_column_values: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartCrawlerRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StartCrawlerResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartCrawlerScheduleRequest {
#[serde(rename = "CrawlerName")]
pub crawler_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StartCrawlerScheduleResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartJobRunRequest {
#[serde(rename = "AllocatedCapacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allocated_capacity: Option<i64>,
#[serde(rename = "Arguments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arguments: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "JobName")]
pub job_name: String,
#[serde(rename = "JobRunId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_run_id: Option<String>,
#[serde(rename = "NotificationProperty")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_property: Option<NotificationProperty>,
#[serde(rename = "Timeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StartJobRunResponse {
#[serde(rename = "JobRunId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_run_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartTriggerRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StartTriggerResponse {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StopCrawlerRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StopCrawlerResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StopCrawlerScheduleRequest {
#[serde(rename = "CrawlerName")]
pub crawler_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StopCrawlerScheduleResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StopTriggerRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StopTriggerResponse {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StorageDescriptor {
#[serde(rename = "BucketColumns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket_columns: Option<Vec<String>>,
#[serde(rename = "Columns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub columns: Option<Vec<Column>>,
#[serde(rename = "Compressed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compressed: Option<bool>,
#[serde(rename = "InputFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_format: Option<String>,
#[serde(rename = "Location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
#[serde(rename = "NumberOfBuckets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_buckets: Option<i64>,
#[serde(rename = "OutputFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_format: Option<String>,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "SerdeInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub serde_info: Option<SerDeInfo>,
#[serde(rename = "SkewedInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skewed_info: Option<SkewedInfo>,
#[serde(rename = "SortColumns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sort_columns: Option<Vec<Order>>,
#[serde(rename = "StoredAsSubDirectories")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stored_as_sub_directories: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Table {
#[serde(rename = "CreateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time: Option<f64>,
#[serde(rename = "CreatedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_by: Option<String>,
#[serde(rename = "DatabaseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database_name: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LastAccessTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_access_time: Option<f64>,
#[serde(rename = "LastAnalyzedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_analyzed_time: Option<f64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "PartitionKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub partition_keys: Option<Vec<Column>>,
#[serde(rename = "Retention")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention: Option<i64>,
#[serde(rename = "StorageDescriptor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage_descriptor: Option<StorageDescriptor>,
#[serde(rename = "TableType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_type: Option<String>,
#[serde(rename = "UpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_time: Option<f64>,
#[serde(rename = "ViewExpandedText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub view_expanded_text: Option<String>,
#[serde(rename = "ViewOriginalText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub view_original_text: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct TableError {
#[serde(rename = "ErrorDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_detail: Option<ErrorDetail>,
#[serde(rename = "TableName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct TableInput {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LastAccessTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_access_time: Option<f64>,
#[serde(rename = "LastAnalyzedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_analyzed_time: Option<f64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "PartitionKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub partition_keys: Option<Vec<Column>>,
#[serde(rename = "Retention")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention: Option<i64>,
#[serde(rename = "StorageDescriptor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage_descriptor: Option<StorageDescriptor>,
#[serde(rename = "TableType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_type: Option<String>,
#[serde(rename = "ViewExpandedText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub view_expanded_text: Option<String>,
#[serde(rename = "ViewOriginalText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub view_original_text: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct TableVersion {
#[serde(rename = "Table")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table: Option<Table>,
#[serde(rename = "VersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct TableVersionError {
#[serde(rename = "ErrorDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_detail: Option<ErrorDetail>,
#[serde(rename = "TableName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_name: Option<String>,
#[serde(rename = "VersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Trigger {
#[serde(rename = "Actions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub actions: Option<Vec<Action>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Predicate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub predicate: Option<Predicate>,
#[serde(rename = "Schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct TriggerUpdate {
#[serde(rename = "Actions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub actions: Option<Vec<Action>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Predicate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub predicate: Option<Predicate>,
#[serde(rename = "Schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateClassifierRequest {
#[serde(rename = "GrokClassifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grok_classifier: Option<UpdateGrokClassifierRequest>,
#[serde(rename = "JsonClassifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub json_classifier: Option<UpdateJsonClassifierRequest>,
#[serde(rename = "XMLClassifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub xml_classifier: Option<UpdateXMLClassifierRequest>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateClassifierResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateConnectionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "ConnectionInput")]
pub connection_input: ConnectionInput,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateConnectionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateCrawlerRequest {
#[serde(rename = "Classifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub classifiers: Option<Vec<String>>,
#[serde(rename = "Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<String>,
#[serde(rename = "DatabaseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database_name: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Role")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role: Option<String>,
#[serde(rename = "Schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<String>,
#[serde(rename = "SchemaChangePolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_change_policy: Option<SchemaChangePolicy>,
#[serde(rename = "TablePrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_prefix: Option<String>,
#[serde(rename = "Targets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub targets: Option<CrawlerTargets>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateCrawlerResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateCrawlerScheduleRequest {
#[serde(rename = "CrawlerName")]
pub crawler_name: String,
#[serde(rename = "Schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateCrawlerScheduleResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateDatabaseRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseInput")]
pub database_input: DatabaseInput,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateDatabaseResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateDevEndpointRequest {
#[serde(rename = "AddPublicKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_public_keys: Option<Vec<String>>,
#[serde(rename = "CustomLibraries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_libraries: Option<DevEndpointCustomLibraries>,
#[serde(rename = "DeletePublicKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_public_keys: Option<Vec<String>>,
#[serde(rename = "EndpointName")]
pub endpoint_name: String,
#[serde(rename = "PublicKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_key: Option<String>,
#[serde(rename = "UpdateEtlLibraries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_etl_libraries: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateDevEndpointResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateGrokClassifierRequest {
#[serde(rename = "Classification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub classification: Option<String>,
#[serde(rename = "CustomPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_patterns: Option<String>,
#[serde(rename = "GrokPattern")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grok_pattern: Option<String>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateJobRequest {
#[serde(rename = "JobName")]
pub job_name: String,
#[serde(rename = "JobUpdate")]
pub job_update: JobUpdate,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateJobResponse {
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateJsonClassifierRequest {
#[serde(rename = "JsonPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub json_path: Option<String>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdatePartitionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "PartitionInput")]
pub partition_input: PartitionInput,
#[serde(rename = "PartitionValueList")]
pub partition_value_list: Vec<String>,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdatePartitionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateTableRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "SkipArchive")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skip_archive: Option<bool>,
#[serde(rename = "TableInput")]
pub table_input: TableInput,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateTableResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateTriggerRequest {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "TriggerUpdate")]
pub trigger_update: TriggerUpdate,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateTriggerResponse {
#[serde(rename = "Trigger")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trigger: Option<Trigger>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateUserDefinedFunctionRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "FunctionInput")]
pub function_input: UserDefinedFunctionInput,
#[serde(rename = "FunctionName")]
pub function_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateUserDefinedFunctionResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateXMLClassifierRequest {
#[serde(rename = "Classification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub classification: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RowTag")]
#[serde(skip_serializing_if = "Option::is_none")]
pub row_tag: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UserDefinedFunction {
#[serde(rename = "ClassName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub class_name: Option<String>,
#[serde(rename = "CreateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time: Option<f64>,
#[serde(rename = "FunctionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_name: Option<String>,
#[serde(rename = "OwnerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_name: Option<String>,
#[serde(rename = "OwnerType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_type: Option<String>,
#[serde(rename = "ResourceUris")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_uris: Option<Vec<ResourceUri>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UserDefinedFunctionInput {
#[serde(rename = "ClassName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub class_name: Option<String>,
#[serde(rename = "FunctionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_name: Option<String>,
#[serde(rename = "OwnerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_name: Option<String>,
#[serde(rename = "OwnerType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_type: Option<String>,
#[serde(rename = "ResourceUris")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_uris: Option<Vec<ResourceUri>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct XMLClassifier {
#[serde(rename = "Classification")]
pub classification: String,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "LastUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated: Option<f64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RowTag")]
#[serde(skip_serializing_if = "Option::is_none")]
pub row_tag: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<i64>,
}
#[derive(Debug, PartialEq)]
pub enum BatchCreatePartitionError {
AlreadyExists(String),
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
ResourceNumberLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl BatchCreatePartitionError {
pub fn from_response(res: BufferedHttpResponse) -> BatchCreatePartitionError {
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 {
"AlreadyExistsException" => {
return BatchCreatePartitionError::AlreadyExists(String::from(error_message))
}
"EntityNotFoundException" => {
return BatchCreatePartitionError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return BatchCreatePartitionError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return BatchCreatePartitionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return BatchCreatePartitionError::OperationTimeout(String::from(error_message))
}
"ResourceNumberLimitExceededException" => {
return BatchCreatePartitionError::ResourceNumberLimitExceeded(String::from(
error_message,
))
}
"ValidationException" => {
return BatchCreatePartitionError::Validation(error_message.to_string())
}
_ => {}
}
}
return BatchCreatePartitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for BatchCreatePartitionError {
fn from(err: serde_json::error::Error) -> BatchCreatePartitionError {
BatchCreatePartitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for BatchCreatePartitionError {
fn from(err: CredentialsError) -> BatchCreatePartitionError {
BatchCreatePartitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for BatchCreatePartitionError {
fn from(err: HttpDispatchError) -> BatchCreatePartitionError {
BatchCreatePartitionError::HttpDispatch(err)
}
}
impl From<io::Error> for BatchCreatePartitionError {
fn from(err: io::Error) -> BatchCreatePartitionError {
BatchCreatePartitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for BatchCreatePartitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for BatchCreatePartitionError {
fn description(&self) -> &str {
match *self {
BatchCreatePartitionError::AlreadyExists(ref cause) => cause,
BatchCreatePartitionError::EntityNotFound(ref cause) => cause,
BatchCreatePartitionError::InternalService(ref cause) => cause,
BatchCreatePartitionError::InvalidInput(ref cause) => cause,
BatchCreatePartitionError::OperationTimeout(ref cause) => cause,
BatchCreatePartitionError::ResourceNumberLimitExceeded(ref cause) => cause,
BatchCreatePartitionError::Validation(ref cause) => cause,
BatchCreatePartitionError::Credentials(ref err) => err.description(),
BatchCreatePartitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
BatchCreatePartitionError::ParseError(ref cause) => cause,
BatchCreatePartitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum BatchDeleteConnectionError {
InternalService(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl BatchDeleteConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> BatchDeleteConnectionError {
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 {
"InternalServiceException" => {
return BatchDeleteConnectionError::InternalService(String::from(error_message))
}
"OperationTimeoutException" => {
return BatchDeleteConnectionError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return BatchDeleteConnectionError::Validation(error_message.to_string())
}
_ => {}
}
}
return BatchDeleteConnectionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for BatchDeleteConnectionError {
fn from(err: serde_json::error::Error) -> BatchDeleteConnectionError {
BatchDeleteConnectionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for BatchDeleteConnectionError {
fn from(err: CredentialsError) -> BatchDeleteConnectionError {
BatchDeleteConnectionError::Credentials(err)
}
}
impl From<HttpDispatchError> for BatchDeleteConnectionError {
fn from(err: HttpDispatchError) -> BatchDeleteConnectionError {
BatchDeleteConnectionError::HttpDispatch(err)
}
}
impl From<io::Error> for BatchDeleteConnectionError {
fn from(err: io::Error) -> BatchDeleteConnectionError {
BatchDeleteConnectionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for BatchDeleteConnectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for BatchDeleteConnectionError {
fn description(&self) -> &str {
match *self {
BatchDeleteConnectionError::InternalService(ref cause) => cause,
BatchDeleteConnectionError::OperationTimeout(ref cause) => cause,
BatchDeleteConnectionError::Validation(ref cause) => cause,
BatchDeleteConnectionError::Credentials(ref err) => err.description(),
BatchDeleteConnectionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
BatchDeleteConnectionError::ParseError(ref cause) => cause,
BatchDeleteConnectionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum BatchDeletePartitionError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl BatchDeletePartitionError {
pub fn from_response(res: BufferedHttpResponse) -> BatchDeletePartitionError {
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 {
"EntityNotFoundException" => {
return BatchDeletePartitionError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return BatchDeletePartitionError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return BatchDeletePartitionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return BatchDeletePartitionError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return BatchDeletePartitionError::Validation(error_message.to_string())
}
_ => {}
}
}
return BatchDeletePartitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for BatchDeletePartitionError {
fn from(err: serde_json::error::Error) -> BatchDeletePartitionError {
BatchDeletePartitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for BatchDeletePartitionError {
fn from(err: CredentialsError) -> BatchDeletePartitionError {
BatchDeletePartitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for BatchDeletePartitionError {
fn from(err: HttpDispatchError) -> BatchDeletePartitionError {
BatchDeletePartitionError::HttpDispatch(err)
}
}
impl From<io::Error> for BatchDeletePartitionError {
fn from(err: io::Error) -> BatchDeletePartitionError {
BatchDeletePartitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for BatchDeletePartitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for BatchDeletePartitionError {
fn description(&self) -> &str {
match *self {
BatchDeletePartitionError::EntityNotFound(ref cause) => cause,
BatchDeletePartitionError::InternalService(ref cause) => cause,
BatchDeletePartitionError::InvalidInput(ref cause) => cause,
BatchDeletePartitionError::OperationTimeout(ref cause) => cause,
BatchDeletePartitionError::Validation(ref cause) => cause,
BatchDeletePartitionError::Credentials(ref err) => err.description(),
BatchDeletePartitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
BatchDeletePartitionError::ParseError(ref cause) => cause,
BatchDeletePartitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum BatchDeleteTableError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl BatchDeleteTableError {
pub fn from_response(res: BufferedHttpResponse) -> BatchDeleteTableError {
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 {
"EntityNotFoundException" => {
return BatchDeleteTableError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return BatchDeleteTableError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return BatchDeleteTableError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return BatchDeleteTableError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return BatchDeleteTableError::Validation(error_message.to_string())
}
_ => {}
}
}
return BatchDeleteTableError::Unknown(res);
}
}
impl From<serde_json::error::Error> for BatchDeleteTableError {
fn from(err: serde_json::error::Error) -> BatchDeleteTableError {
BatchDeleteTableError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for BatchDeleteTableError {
fn from(err: CredentialsError) -> BatchDeleteTableError {
BatchDeleteTableError::Credentials(err)
}
}
impl From<HttpDispatchError> for BatchDeleteTableError {
fn from(err: HttpDispatchError) -> BatchDeleteTableError {
BatchDeleteTableError::HttpDispatch(err)
}
}
impl From<io::Error> for BatchDeleteTableError {
fn from(err: io::Error) -> BatchDeleteTableError {
BatchDeleteTableError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for BatchDeleteTableError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for BatchDeleteTableError {
fn description(&self) -> &str {
match *self {
BatchDeleteTableError::EntityNotFound(ref cause) => cause,
BatchDeleteTableError::InternalService(ref cause) => cause,
BatchDeleteTableError::InvalidInput(ref cause) => cause,
BatchDeleteTableError::OperationTimeout(ref cause) => cause,
BatchDeleteTableError::Validation(ref cause) => cause,
BatchDeleteTableError::Credentials(ref err) => err.description(),
BatchDeleteTableError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
BatchDeleteTableError::ParseError(ref cause) => cause,
BatchDeleteTableError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum BatchDeleteTableVersionError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl BatchDeleteTableVersionError {
pub fn from_response(res: BufferedHttpResponse) -> BatchDeleteTableVersionError {
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 {
"EntityNotFoundException" => {
return BatchDeleteTableVersionError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return BatchDeleteTableVersionError::InternalService(String::from(
error_message,
))
}
"InvalidInputException" => {
return BatchDeleteTableVersionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return BatchDeleteTableVersionError::OperationTimeout(String::from(
error_message,
))
}
"ValidationException" => {
return BatchDeleteTableVersionError::Validation(error_message.to_string())
}
_ => {}
}
}
return BatchDeleteTableVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for BatchDeleteTableVersionError {
fn from(err: serde_json::error::Error) -> BatchDeleteTableVersionError {
BatchDeleteTableVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for BatchDeleteTableVersionError {
fn from(err: CredentialsError) -> BatchDeleteTableVersionError {
BatchDeleteTableVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for BatchDeleteTableVersionError {
fn from(err: HttpDispatchError) -> BatchDeleteTableVersionError {
BatchDeleteTableVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for BatchDeleteTableVersionError {
fn from(err: io::Error) -> BatchDeleteTableVersionError {
BatchDeleteTableVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for BatchDeleteTableVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for BatchDeleteTableVersionError {
fn description(&self) -> &str {
match *self {
BatchDeleteTableVersionError::EntityNotFound(ref cause) => cause,
BatchDeleteTableVersionError::InternalService(ref cause) => cause,
BatchDeleteTableVersionError::InvalidInput(ref cause) => cause,
BatchDeleteTableVersionError::OperationTimeout(ref cause) => cause,
BatchDeleteTableVersionError::Validation(ref cause) => cause,
BatchDeleteTableVersionError::Credentials(ref err) => err.description(),
BatchDeleteTableVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
BatchDeleteTableVersionError::ParseError(ref cause) => cause,
BatchDeleteTableVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum BatchGetPartitionError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl BatchGetPartitionError {
pub fn from_response(res: BufferedHttpResponse) -> BatchGetPartitionError {
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 {
"EntityNotFoundException" => {
return BatchGetPartitionError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return BatchGetPartitionError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return BatchGetPartitionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return BatchGetPartitionError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return BatchGetPartitionError::Validation(error_message.to_string())
}
_ => {}
}
}
return BatchGetPartitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for BatchGetPartitionError {
fn from(err: serde_json::error::Error) -> BatchGetPartitionError {
BatchGetPartitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for BatchGetPartitionError {
fn from(err: CredentialsError) -> BatchGetPartitionError {
BatchGetPartitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for BatchGetPartitionError {
fn from(err: HttpDispatchError) -> BatchGetPartitionError {
BatchGetPartitionError::HttpDispatch(err)
}
}
impl From<io::Error> for BatchGetPartitionError {
fn from(err: io::Error) -> BatchGetPartitionError {
BatchGetPartitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for BatchGetPartitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for BatchGetPartitionError {
fn description(&self) -> &str {
match *self {
BatchGetPartitionError::EntityNotFound(ref cause) => cause,
BatchGetPartitionError::InternalService(ref cause) => cause,
BatchGetPartitionError::InvalidInput(ref cause) => cause,
BatchGetPartitionError::OperationTimeout(ref cause) => cause,
BatchGetPartitionError::Validation(ref cause) => cause,
BatchGetPartitionError::Credentials(ref err) => err.description(),
BatchGetPartitionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
BatchGetPartitionError::ParseError(ref cause) => cause,
BatchGetPartitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GlueBatchStopJobRunError {
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GlueBatchStopJobRunError {
pub fn from_response(res: BufferedHttpResponse) -> GlueBatchStopJobRunError {
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 {
"InternalServiceException" => {
return GlueBatchStopJobRunError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GlueBatchStopJobRunError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GlueBatchStopJobRunError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GlueBatchStopJobRunError::Validation(error_message.to_string())
}
_ => {}
}
}
return GlueBatchStopJobRunError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GlueBatchStopJobRunError {
fn from(err: serde_json::error::Error) -> GlueBatchStopJobRunError {
GlueBatchStopJobRunError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GlueBatchStopJobRunError {
fn from(err: CredentialsError) -> GlueBatchStopJobRunError {
GlueBatchStopJobRunError::Credentials(err)
}
}
impl From<HttpDispatchError> for GlueBatchStopJobRunError {
fn from(err: HttpDispatchError) -> GlueBatchStopJobRunError {
GlueBatchStopJobRunError::HttpDispatch(err)
}
}
impl From<io::Error> for GlueBatchStopJobRunError {
fn from(err: io::Error) -> GlueBatchStopJobRunError {
GlueBatchStopJobRunError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GlueBatchStopJobRunError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GlueBatchStopJobRunError {
fn description(&self) -> &str {
match *self {
GlueBatchStopJobRunError::InternalService(ref cause) => cause,
GlueBatchStopJobRunError::InvalidInput(ref cause) => cause,
GlueBatchStopJobRunError::OperationTimeout(ref cause) => cause,
GlueBatchStopJobRunError::Validation(ref cause) => cause,
GlueBatchStopJobRunError::Credentials(ref err) => err.description(),
GlueBatchStopJobRunError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GlueBatchStopJobRunError::ParseError(ref cause) => cause,
GlueBatchStopJobRunError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateClassifierError {
AlreadyExists(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateClassifierError {
pub fn from_response(res: BufferedHttpResponse) -> CreateClassifierError {
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 {
"AlreadyExistsException" => {
return CreateClassifierError::AlreadyExists(String::from(error_message))
}
"InvalidInputException" => {
return CreateClassifierError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return CreateClassifierError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return CreateClassifierError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateClassifierError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateClassifierError {
fn from(err: serde_json::error::Error) -> CreateClassifierError {
CreateClassifierError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateClassifierError {
fn from(err: CredentialsError) -> CreateClassifierError {
CreateClassifierError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateClassifierError {
fn from(err: HttpDispatchError) -> CreateClassifierError {
CreateClassifierError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateClassifierError {
fn from(err: io::Error) -> CreateClassifierError {
CreateClassifierError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateClassifierError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateClassifierError {
fn description(&self) -> &str {
match *self {
CreateClassifierError::AlreadyExists(ref cause) => cause,
CreateClassifierError::InvalidInput(ref cause) => cause,
CreateClassifierError::OperationTimeout(ref cause) => cause,
CreateClassifierError::Validation(ref cause) => cause,
CreateClassifierError::Credentials(ref err) => err.description(),
CreateClassifierError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateClassifierError::ParseError(ref cause) => cause,
CreateClassifierError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateConnectionError {
AlreadyExists(String),
InvalidInput(String),
OperationTimeout(String),
ResourceNumberLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateConnectionError {
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 {
"AlreadyExistsException" => {
return CreateConnectionError::AlreadyExists(String::from(error_message))
}
"InvalidInputException" => {
return CreateConnectionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return CreateConnectionError::OperationTimeout(String::from(error_message))
}
"ResourceNumberLimitExceededException" => {
return CreateConnectionError::ResourceNumberLimitExceeded(String::from(
error_message,
))
}
"ValidationException" => {
return CreateConnectionError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateConnectionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateConnectionError {
fn from(err: serde_json::error::Error) -> CreateConnectionError {
CreateConnectionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateConnectionError {
fn from(err: CredentialsError) -> CreateConnectionError {
CreateConnectionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateConnectionError {
fn from(err: HttpDispatchError) -> CreateConnectionError {
CreateConnectionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateConnectionError {
fn from(err: io::Error) -> CreateConnectionError {
CreateConnectionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateConnectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateConnectionError {
fn description(&self) -> &str {
match *self {
CreateConnectionError::AlreadyExists(ref cause) => cause,
CreateConnectionError::InvalidInput(ref cause) => cause,
CreateConnectionError::OperationTimeout(ref cause) => cause,
CreateConnectionError::ResourceNumberLimitExceeded(ref cause) => cause,
CreateConnectionError::Validation(ref cause) => cause,
CreateConnectionError::Credentials(ref err) => err.description(),
CreateConnectionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateConnectionError::ParseError(ref cause) => cause,
CreateConnectionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateCrawlerError {
AlreadyExists(String),
InvalidInput(String),
OperationTimeout(String),
ResourceNumberLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateCrawlerError {
pub fn from_response(res: BufferedHttpResponse) -> CreateCrawlerError {
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 {
"AlreadyExistsException" => {
return CreateCrawlerError::AlreadyExists(String::from(error_message))
}
"InvalidInputException" => {
return CreateCrawlerError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return CreateCrawlerError::OperationTimeout(String::from(error_message))
}
"ResourceNumberLimitExceededException" => {
return CreateCrawlerError::ResourceNumberLimitExceeded(String::from(
error_message,
))
}
"ValidationException" => {
return CreateCrawlerError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateCrawlerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateCrawlerError {
fn from(err: serde_json::error::Error) -> CreateCrawlerError {
CreateCrawlerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateCrawlerError {
fn from(err: CredentialsError) -> CreateCrawlerError {
CreateCrawlerError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateCrawlerError {
fn from(err: HttpDispatchError) -> CreateCrawlerError {
CreateCrawlerError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateCrawlerError {
fn from(err: io::Error) -> CreateCrawlerError {
CreateCrawlerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateCrawlerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateCrawlerError {
fn description(&self) -> &str {
match *self {
CreateCrawlerError::AlreadyExists(ref cause) => cause,
CreateCrawlerError::InvalidInput(ref cause) => cause,
CreateCrawlerError::OperationTimeout(ref cause) => cause,
CreateCrawlerError::ResourceNumberLimitExceeded(ref cause) => cause,
CreateCrawlerError::Validation(ref cause) => cause,
CreateCrawlerError::Credentials(ref err) => err.description(),
CreateCrawlerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateCrawlerError::ParseError(ref cause) => cause,
CreateCrawlerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDatabaseError {
AlreadyExists(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
ResourceNumberLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDatabaseError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDatabaseError {
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 {
"AlreadyExistsException" => {
return CreateDatabaseError::AlreadyExists(String::from(error_message))
}
"InternalServiceException" => {
return CreateDatabaseError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return CreateDatabaseError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return CreateDatabaseError::OperationTimeout(String::from(error_message))
}
"ResourceNumberLimitExceededException" => {
return CreateDatabaseError::ResourceNumberLimitExceeded(String::from(
error_message,
))
}
"ValidationException" => {
return CreateDatabaseError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateDatabaseError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateDatabaseError {
fn from(err: serde_json::error::Error) -> CreateDatabaseError {
CreateDatabaseError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateDatabaseError {
fn from(err: CredentialsError) -> CreateDatabaseError {
CreateDatabaseError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDatabaseError {
fn from(err: HttpDispatchError) -> CreateDatabaseError {
CreateDatabaseError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDatabaseError {
fn from(err: io::Error) -> CreateDatabaseError {
CreateDatabaseError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDatabaseError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDatabaseError {
fn description(&self) -> &str {
match *self {
CreateDatabaseError::AlreadyExists(ref cause) => cause,
CreateDatabaseError::InternalService(ref cause) => cause,
CreateDatabaseError::InvalidInput(ref cause) => cause,
CreateDatabaseError::OperationTimeout(ref cause) => cause,
CreateDatabaseError::ResourceNumberLimitExceeded(ref cause) => cause,
CreateDatabaseError::Validation(ref cause) => cause,
CreateDatabaseError::Credentials(ref err) => err.description(),
CreateDatabaseError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateDatabaseError::ParseError(ref cause) => cause,
CreateDatabaseError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateDevEndpointError {
AccessDenied(String),
AlreadyExists(String),
IdempotentParameterMismatch(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
ResourceNumberLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateDevEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> CreateDevEndpointError {
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 {
"AccessDeniedException" => {
return CreateDevEndpointError::AccessDenied(String::from(error_message))
}
"AlreadyExistsException" => {
return CreateDevEndpointError::AlreadyExists(String::from(error_message))
}
"IdempotentParameterMismatchException" => {
return CreateDevEndpointError::IdempotentParameterMismatch(String::from(
error_message,
))
}
"InternalServiceException" => {
return CreateDevEndpointError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return CreateDevEndpointError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return CreateDevEndpointError::OperationTimeout(String::from(error_message))
}
"ResourceNumberLimitExceededException" => {
return CreateDevEndpointError::ResourceNumberLimitExceeded(String::from(
error_message,
))
}
"ValidationException" => {
return CreateDevEndpointError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateDevEndpointError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateDevEndpointError {
fn from(err: serde_json::error::Error) -> CreateDevEndpointError {
CreateDevEndpointError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateDevEndpointError {
fn from(err: CredentialsError) -> CreateDevEndpointError {
CreateDevEndpointError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateDevEndpointError {
fn from(err: HttpDispatchError) -> CreateDevEndpointError {
CreateDevEndpointError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateDevEndpointError {
fn from(err: io::Error) -> CreateDevEndpointError {
CreateDevEndpointError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateDevEndpointError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateDevEndpointError {
fn description(&self) -> &str {
match *self {
CreateDevEndpointError::AccessDenied(ref cause) => cause,
CreateDevEndpointError::AlreadyExists(ref cause) => cause,
CreateDevEndpointError::IdempotentParameterMismatch(ref cause) => cause,
CreateDevEndpointError::InternalService(ref cause) => cause,
CreateDevEndpointError::InvalidInput(ref cause) => cause,
CreateDevEndpointError::OperationTimeout(ref cause) => cause,
CreateDevEndpointError::ResourceNumberLimitExceeded(ref cause) => cause,
CreateDevEndpointError::Validation(ref cause) => cause,
CreateDevEndpointError::Credentials(ref err) => err.description(),
CreateDevEndpointError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateDevEndpointError::ParseError(ref cause) => cause,
CreateDevEndpointError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateJobError {
AlreadyExists(String),
ConcurrentModification(String),
IdempotentParameterMismatch(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
ResourceNumberLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateJobError {
pub fn from_response(res: BufferedHttpResponse) -> CreateJobError {
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 {
"AlreadyExistsException" => {
return CreateJobError::AlreadyExists(String::from(error_message))
}
"ConcurrentModificationException" => {
return CreateJobError::ConcurrentModification(String::from(error_message))
}
"IdempotentParameterMismatchException" => {
return CreateJobError::IdempotentParameterMismatch(String::from(error_message))
}
"InternalServiceException" => {
return CreateJobError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return CreateJobError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return CreateJobError::OperationTimeout(String::from(error_message))
}
"ResourceNumberLimitExceededException" => {
return CreateJobError::ResourceNumberLimitExceeded(String::from(error_message))
}
"ValidationException" => {
return CreateJobError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateJobError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateJobError {
fn from(err: serde_json::error::Error) -> CreateJobError {
CreateJobError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateJobError {
fn from(err: CredentialsError) -> CreateJobError {
CreateJobError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateJobError {
fn from(err: HttpDispatchError) -> CreateJobError {
CreateJobError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateJobError {
fn from(err: io::Error) -> CreateJobError {
CreateJobError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateJobError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateJobError {
fn description(&self) -> &str {
match *self {
CreateJobError::AlreadyExists(ref cause) => cause,
CreateJobError::ConcurrentModification(ref cause) => cause,
CreateJobError::IdempotentParameterMismatch(ref cause) => cause,
CreateJobError::InternalService(ref cause) => cause,
CreateJobError::InvalidInput(ref cause) => cause,
CreateJobError::OperationTimeout(ref cause) => cause,
CreateJobError::ResourceNumberLimitExceeded(ref cause) => cause,
CreateJobError::Validation(ref cause) => cause,
CreateJobError::Credentials(ref err) => err.description(),
CreateJobError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateJobError::ParseError(ref cause) => cause,
CreateJobError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreatePartitionError {
AlreadyExists(String),
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
ResourceNumberLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreatePartitionError {
pub fn from_response(res: BufferedHttpResponse) -> CreatePartitionError {
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 {
"AlreadyExistsException" => {
return CreatePartitionError::AlreadyExists(String::from(error_message))
}
"EntityNotFoundException" => {
return CreatePartitionError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return CreatePartitionError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return CreatePartitionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return CreatePartitionError::OperationTimeout(String::from(error_message))
}
"ResourceNumberLimitExceededException" => {
return CreatePartitionError::ResourceNumberLimitExceeded(String::from(
error_message,
))
}
"ValidationException" => {
return CreatePartitionError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreatePartitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreatePartitionError {
fn from(err: serde_json::error::Error) -> CreatePartitionError {
CreatePartitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreatePartitionError {
fn from(err: CredentialsError) -> CreatePartitionError {
CreatePartitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreatePartitionError {
fn from(err: HttpDispatchError) -> CreatePartitionError {
CreatePartitionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreatePartitionError {
fn from(err: io::Error) -> CreatePartitionError {
CreatePartitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreatePartitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreatePartitionError {
fn description(&self) -> &str {
match *self {
CreatePartitionError::AlreadyExists(ref cause) => cause,
CreatePartitionError::EntityNotFound(ref cause) => cause,
CreatePartitionError::InternalService(ref cause) => cause,
CreatePartitionError::InvalidInput(ref cause) => cause,
CreatePartitionError::OperationTimeout(ref cause) => cause,
CreatePartitionError::ResourceNumberLimitExceeded(ref cause) => cause,
CreatePartitionError::Validation(ref cause) => cause,
CreatePartitionError::Credentials(ref err) => err.description(),
CreatePartitionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreatePartitionError::ParseError(ref cause) => cause,
CreatePartitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateScriptError {
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateScriptError {
pub fn from_response(res: BufferedHttpResponse) -> CreateScriptError {
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 {
"InternalServiceException" => {
return CreateScriptError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return CreateScriptError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return CreateScriptError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return CreateScriptError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateScriptError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateScriptError {
fn from(err: serde_json::error::Error) -> CreateScriptError {
CreateScriptError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateScriptError {
fn from(err: CredentialsError) -> CreateScriptError {
CreateScriptError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateScriptError {
fn from(err: HttpDispatchError) -> CreateScriptError {
CreateScriptError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateScriptError {
fn from(err: io::Error) -> CreateScriptError {
CreateScriptError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateScriptError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateScriptError {
fn description(&self) -> &str {
match *self {
CreateScriptError::InternalService(ref cause) => cause,
CreateScriptError::InvalidInput(ref cause) => cause,
CreateScriptError::OperationTimeout(ref cause) => cause,
CreateScriptError::Validation(ref cause) => cause,
CreateScriptError::Credentials(ref err) => err.description(),
CreateScriptError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateScriptError::ParseError(ref cause) => cause,
CreateScriptError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateTableError {
AlreadyExists(String),
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
ResourceNumberLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateTableError {
pub fn from_response(res: BufferedHttpResponse) -> CreateTableError {
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 {
"AlreadyExistsException" => {
return CreateTableError::AlreadyExists(String::from(error_message))
}
"EntityNotFoundException" => {
return CreateTableError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return CreateTableError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return CreateTableError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return CreateTableError::OperationTimeout(String::from(error_message))
}
"ResourceNumberLimitExceededException" => {
return CreateTableError::ResourceNumberLimitExceeded(String::from(
error_message,
))
}
"ValidationException" => {
return CreateTableError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateTableError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateTableError {
fn from(err: serde_json::error::Error) -> CreateTableError {
CreateTableError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateTableError {
fn from(err: CredentialsError) -> CreateTableError {
CreateTableError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateTableError {
fn from(err: HttpDispatchError) -> CreateTableError {
CreateTableError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateTableError {
fn from(err: io::Error) -> CreateTableError {
CreateTableError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateTableError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateTableError {
fn description(&self) -> &str {
match *self {
CreateTableError::AlreadyExists(ref cause) => cause,
CreateTableError::EntityNotFound(ref cause) => cause,
CreateTableError::InternalService(ref cause) => cause,
CreateTableError::InvalidInput(ref cause) => cause,
CreateTableError::OperationTimeout(ref cause) => cause,
CreateTableError::ResourceNumberLimitExceeded(ref cause) => cause,
CreateTableError::Validation(ref cause) => cause,
CreateTableError::Credentials(ref err) => err.description(),
CreateTableError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateTableError::ParseError(ref cause) => cause,
CreateTableError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateTriggerError {
AlreadyExists(String),
ConcurrentModification(String),
IdempotentParameterMismatch(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
ResourceNumberLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateTriggerError {
pub fn from_response(res: BufferedHttpResponse) -> CreateTriggerError {
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 {
"AlreadyExistsException" => {
return CreateTriggerError::AlreadyExists(String::from(error_message))
}
"ConcurrentModificationException" => {
return CreateTriggerError::ConcurrentModification(String::from(error_message))
}
"IdempotentParameterMismatchException" => {
return CreateTriggerError::IdempotentParameterMismatch(String::from(
error_message,
))
}
"InternalServiceException" => {
return CreateTriggerError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return CreateTriggerError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return CreateTriggerError::OperationTimeout(String::from(error_message))
}
"ResourceNumberLimitExceededException" => {
return CreateTriggerError::ResourceNumberLimitExceeded(String::from(
error_message,
))
}
"ValidationException" => {
return CreateTriggerError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateTriggerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateTriggerError {
fn from(err: serde_json::error::Error) -> CreateTriggerError {
CreateTriggerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateTriggerError {
fn from(err: CredentialsError) -> CreateTriggerError {
CreateTriggerError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateTriggerError {
fn from(err: HttpDispatchError) -> CreateTriggerError {
CreateTriggerError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateTriggerError {
fn from(err: io::Error) -> CreateTriggerError {
CreateTriggerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateTriggerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateTriggerError {
fn description(&self) -> &str {
match *self {
CreateTriggerError::AlreadyExists(ref cause) => cause,
CreateTriggerError::ConcurrentModification(ref cause) => cause,
CreateTriggerError::IdempotentParameterMismatch(ref cause) => cause,
CreateTriggerError::InternalService(ref cause) => cause,
CreateTriggerError::InvalidInput(ref cause) => cause,
CreateTriggerError::OperationTimeout(ref cause) => cause,
CreateTriggerError::ResourceNumberLimitExceeded(ref cause) => cause,
CreateTriggerError::Validation(ref cause) => cause,
CreateTriggerError::Credentials(ref err) => err.description(),
CreateTriggerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateTriggerError::ParseError(ref cause) => cause,
CreateTriggerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateUserDefinedFunctionError {
AlreadyExists(String),
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
ResourceNumberLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateUserDefinedFunctionError {
pub fn from_response(res: BufferedHttpResponse) -> CreateUserDefinedFunctionError {
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 {
"AlreadyExistsException" => {
return CreateUserDefinedFunctionError::AlreadyExists(String::from(
error_message,
))
}
"EntityNotFoundException" => {
return CreateUserDefinedFunctionError::EntityNotFound(String::from(
error_message,
))
}
"InternalServiceException" => {
return CreateUserDefinedFunctionError::InternalService(String::from(
error_message,
))
}
"InvalidInputException" => {
return CreateUserDefinedFunctionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return CreateUserDefinedFunctionError::OperationTimeout(String::from(
error_message,
))
}
"ResourceNumberLimitExceededException" => {
return CreateUserDefinedFunctionError::ResourceNumberLimitExceeded(
String::from(error_message),
)
}
"ValidationException" => {
return CreateUserDefinedFunctionError::Validation(error_message.to_string())
}
_ => {}
}
}
return CreateUserDefinedFunctionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateUserDefinedFunctionError {
fn from(err: serde_json::error::Error) -> CreateUserDefinedFunctionError {
CreateUserDefinedFunctionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateUserDefinedFunctionError {
fn from(err: CredentialsError) -> CreateUserDefinedFunctionError {
CreateUserDefinedFunctionError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateUserDefinedFunctionError {
fn from(err: HttpDispatchError) -> CreateUserDefinedFunctionError {
CreateUserDefinedFunctionError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateUserDefinedFunctionError {
fn from(err: io::Error) -> CreateUserDefinedFunctionError {
CreateUserDefinedFunctionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateUserDefinedFunctionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateUserDefinedFunctionError {
fn description(&self) -> &str {
match *self {
CreateUserDefinedFunctionError::AlreadyExists(ref cause) => cause,
CreateUserDefinedFunctionError::EntityNotFound(ref cause) => cause,
CreateUserDefinedFunctionError::InternalService(ref cause) => cause,
CreateUserDefinedFunctionError::InvalidInput(ref cause) => cause,
CreateUserDefinedFunctionError::OperationTimeout(ref cause) => cause,
CreateUserDefinedFunctionError::ResourceNumberLimitExceeded(ref cause) => cause,
CreateUserDefinedFunctionError::Validation(ref cause) => cause,
CreateUserDefinedFunctionError::Credentials(ref err) => err.description(),
CreateUserDefinedFunctionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateUserDefinedFunctionError::ParseError(ref cause) => cause,
CreateUserDefinedFunctionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteClassifierError {
EntityNotFound(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteClassifierError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteClassifierError {
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 {
"EntityNotFoundException" => {
return DeleteClassifierError::EntityNotFound(String::from(error_message))
}
"OperationTimeoutException" => {
return DeleteClassifierError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return DeleteClassifierError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteClassifierError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteClassifierError {
fn from(err: serde_json::error::Error) -> DeleteClassifierError {
DeleteClassifierError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteClassifierError {
fn from(err: CredentialsError) -> DeleteClassifierError {
DeleteClassifierError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteClassifierError {
fn from(err: HttpDispatchError) -> DeleteClassifierError {
DeleteClassifierError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteClassifierError {
fn from(err: io::Error) -> DeleteClassifierError {
DeleteClassifierError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteClassifierError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteClassifierError {
fn description(&self) -> &str {
match *self {
DeleteClassifierError::EntityNotFound(ref cause) => cause,
DeleteClassifierError::OperationTimeout(ref cause) => cause,
DeleteClassifierError::Validation(ref cause) => cause,
DeleteClassifierError::Credentials(ref err) => err.description(),
DeleteClassifierError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteClassifierError::ParseError(ref cause) => cause,
DeleteClassifierError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteConnectionError {
EntityNotFound(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteConnectionError {
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 {
"EntityNotFoundException" => {
return DeleteConnectionError::EntityNotFound(String::from(error_message))
}
"OperationTimeoutException" => {
return DeleteConnectionError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return DeleteConnectionError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteConnectionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteConnectionError {
fn from(err: serde_json::error::Error) -> DeleteConnectionError {
DeleteConnectionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteConnectionError {
fn from(err: CredentialsError) -> DeleteConnectionError {
DeleteConnectionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteConnectionError {
fn from(err: HttpDispatchError) -> DeleteConnectionError {
DeleteConnectionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteConnectionError {
fn from(err: io::Error) -> DeleteConnectionError {
DeleteConnectionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteConnectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteConnectionError {
fn description(&self) -> &str {
match *self {
DeleteConnectionError::EntityNotFound(ref cause) => cause,
DeleteConnectionError::OperationTimeout(ref cause) => cause,
DeleteConnectionError::Validation(ref cause) => cause,
DeleteConnectionError::Credentials(ref err) => err.description(),
DeleteConnectionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteConnectionError::ParseError(ref cause) => cause,
DeleteConnectionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteCrawlerError {
CrawlerRunning(String),
EntityNotFound(String),
OperationTimeout(String),
SchedulerTransitioning(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteCrawlerError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteCrawlerError {
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 {
"CrawlerRunningException" => {
return DeleteCrawlerError::CrawlerRunning(String::from(error_message))
}
"EntityNotFoundException" => {
return DeleteCrawlerError::EntityNotFound(String::from(error_message))
}
"OperationTimeoutException" => {
return DeleteCrawlerError::OperationTimeout(String::from(error_message))
}
"SchedulerTransitioningException" => {
return DeleteCrawlerError::SchedulerTransitioning(String::from(error_message))
}
"ValidationException" => {
return DeleteCrawlerError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteCrawlerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteCrawlerError {
fn from(err: serde_json::error::Error) -> DeleteCrawlerError {
DeleteCrawlerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteCrawlerError {
fn from(err: CredentialsError) -> DeleteCrawlerError {
DeleteCrawlerError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteCrawlerError {
fn from(err: HttpDispatchError) -> DeleteCrawlerError {
DeleteCrawlerError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteCrawlerError {
fn from(err: io::Error) -> DeleteCrawlerError {
DeleteCrawlerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteCrawlerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteCrawlerError {
fn description(&self) -> &str {
match *self {
DeleteCrawlerError::CrawlerRunning(ref cause) => cause,
DeleteCrawlerError::EntityNotFound(ref cause) => cause,
DeleteCrawlerError::OperationTimeout(ref cause) => cause,
DeleteCrawlerError::SchedulerTransitioning(ref cause) => cause,
DeleteCrawlerError::Validation(ref cause) => cause,
DeleteCrawlerError::Credentials(ref err) => err.description(),
DeleteCrawlerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteCrawlerError::ParseError(ref cause) => cause,
DeleteCrawlerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteDatabaseError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteDatabaseError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteDatabaseError {
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 {
"EntityNotFoundException" => {
return DeleteDatabaseError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return DeleteDatabaseError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return DeleteDatabaseError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return DeleteDatabaseError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return DeleteDatabaseError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteDatabaseError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteDatabaseError {
fn from(err: serde_json::error::Error) -> DeleteDatabaseError {
DeleteDatabaseError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteDatabaseError {
fn from(err: CredentialsError) -> DeleteDatabaseError {
DeleteDatabaseError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteDatabaseError {
fn from(err: HttpDispatchError) -> DeleteDatabaseError {
DeleteDatabaseError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteDatabaseError {
fn from(err: io::Error) -> DeleteDatabaseError {
DeleteDatabaseError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteDatabaseError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDatabaseError {
fn description(&self) -> &str {
match *self {
DeleteDatabaseError::EntityNotFound(ref cause) => cause,
DeleteDatabaseError::InternalService(ref cause) => cause,
DeleteDatabaseError::InvalidInput(ref cause) => cause,
DeleteDatabaseError::OperationTimeout(ref cause) => cause,
DeleteDatabaseError::Validation(ref cause) => cause,
DeleteDatabaseError::Credentials(ref err) => err.description(),
DeleteDatabaseError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteDatabaseError::ParseError(ref cause) => cause,
DeleteDatabaseError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteDevEndpointError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteDevEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteDevEndpointError {
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 {
"EntityNotFoundException" => {
return DeleteDevEndpointError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return DeleteDevEndpointError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return DeleteDevEndpointError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return DeleteDevEndpointError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return DeleteDevEndpointError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteDevEndpointError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteDevEndpointError {
fn from(err: serde_json::error::Error) -> DeleteDevEndpointError {
DeleteDevEndpointError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteDevEndpointError {
fn from(err: CredentialsError) -> DeleteDevEndpointError {
DeleteDevEndpointError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteDevEndpointError {
fn from(err: HttpDispatchError) -> DeleteDevEndpointError {
DeleteDevEndpointError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteDevEndpointError {
fn from(err: io::Error) -> DeleteDevEndpointError {
DeleteDevEndpointError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteDevEndpointError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteDevEndpointError {
fn description(&self) -> &str {
match *self {
DeleteDevEndpointError::EntityNotFound(ref cause) => cause,
DeleteDevEndpointError::InternalService(ref cause) => cause,
DeleteDevEndpointError::InvalidInput(ref cause) => cause,
DeleteDevEndpointError::OperationTimeout(ref cause) => cause,
DeleteDevEndpointError::Validation(ref cause) => cause,
DeleteDevEndpointError::Credentials(ref err) => err.description(),
DeleteDevEndpointError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteDevEndpointError::ParseError(ref cause) => cause,
DeleteDevEndpointError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteJobError {
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteJobError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteJobError {
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 {
"InternalServiceException" => {
return DeleteJobError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return DeleteJobError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return DeleteJobError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return DeleteJobError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteJobError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteJobError {
fn from(err: serde_json::error::Error) -> DeleteJobError {
DeleteJobError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteJobError {
fn from(err: CredentialsError) -> DeleteJobError {
DeleteJobError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteJobError {
fn from(err: HttpDispatchError) -> DeleteJobError {
DeleteJobError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteJobError {
fn from(err: io::Error) -> DeleteJobError {
DeleteJobError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteJobError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteJobError {
fn description(&self) -> &str {
match *self {
DeleteJobError::InternalService(ref cause) => cause,
DeleteJobError::InvalidInput(ref cause) => cause,
DeleteJobError::OperationTimeout(ref cause) => cause,
DeleteJobError::Validation(ref cause) => cause,
DeleteJobError::Credentials(ref err) => err.description(),
DeleteJobError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteJobError::ParseError(ref cause) => cause,
DeleteJobError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeletePartitionError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeletePartitionError {
pub fn from_response(res: BufferedHttpResponse) -> DeletePartitionError {
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 {
"EntityNotFoundException" => {
return DeletePartitionError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return DeletePartitionError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return DeletePartitionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return DeletePartitionError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return DeletePartitionError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeletePartitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeletePartitionError {
fn from(err: serde_json::error::Error) -> DeletePartitionError {
DeletePartitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeletePartitionError {
fn from(err: CredentialsError) -> DeletePartitionError {
DeletePartitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeletePartitionError {
fn from(err: HttpDispatchError) -> DeletePartitionError {
DeletePartitionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeletePartitionError {
fn from(err: io::Error) -> DeletePartitionError {
DeletePartitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeletePartitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeletePartitionError {
fn description(&self) -> &str {
match *self {
DeletePartitionError::EntityNotFound(ref cause) => cause,
DeletePartitionError::InternalService(ref cause) => cause,
DeletePartitionError::InvalidInput(ref cause) => cause,
DeletePartitionError::OperationTimeout(ref cause) => cause,
DeletePartitionError::Validation(ref cause) => cause,
DeletePartitionError::Credentials(ref err) => err.description(),
DeletePartitionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeletePartitionError::ParseError(ref cause) => cause,
DeletePartitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteTableError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteTableError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteTableError {
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 {
"EntityNotFoundException" => {
return DeleteTableError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return DeleteTableError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return DeleteTableError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return DeleteTableError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return DeleteTableError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteTableError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteTableError {
fn from(err: serde_json::error::Error) -> DeleteTableError {
DeleteTableError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteTableError {
fn from(err: CredentialsError) -> DeleteTableError {
DeleteTableError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteTableError {
fn from(err: HttpDispatchError) -> DeleteTableError {
DeleteTableError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteTableError {
fn from(err: io::Error) -> DeleteTableError {
DeleteTableError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteTableError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteTableError {
fn description(&self) -> &str {
match *self {
DeleteTableError::EntityNotFound(ref cause) => cause,
DeleteTableError::InternalService(ref cause) => cause,
DeleteTableError::InvalidInput(ref cause) => cause,
DeleteTableError::OperationTimeout(ref cause) => cause,
DeleteTableError::Validation(ref cause) => cause,
DeleteTableError::Credentials(ref err) => err.description(),
DeleteTableError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteTableError::ParseError(ref cause) => cause,
DeleteTableError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteTableVersionError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteTableVersionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteTableVersionError {
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 {
"EntityNotFoundException" => {
return DeleteTableVersionError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return DeleteTableVersionError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return DeleteTableVersionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return DeleteTableVersionError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return DeleteTableVersionError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteTableVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteTableVersionError {
fn from(err: serde_json::error::Error) -> DeleteTableVersionError {
DeleteTableVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteTableVersionError {
fn from(err: CredentialsError) -> DeleteTableVersionError {
DeleteTableVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteTableVersionError {
fn from(err: HttpDispatchError) -> DeleteTableVersionError {
DeleteTableVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteTableVersionError {
fn from(err: io::Error) -> DeleteTableVersionError {
DeleteTableVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteTableVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteTableVersionError {
fn description(&self) -> &str {
match *self {
DeleteTableVersionError::EntityNotFound(ref cause) => cause,
DeleteTableVersionError::InternalService(ref cause) => cause,
DeleteTableVersionError::InvalidInput(ref cause) => cause,
DeleteTableVersionError::OperationTimeout(ref cause) => cause,
DeleteTableVersionError::Validation(ref cause) => cause,
DeleteTableVersionError::Credentials(ref err) => err.description(),
DeleteTableVersionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteTableVersionError::ParseError(ref cause) => cause,
DeleteTableVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteTriggerError {
ConcurrentModification(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteTriggerError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteTriggerError {
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 DeleteTriggerError::ConcurrentModification(String::from(error_message))
}
"InternalServiceException" => {
return DeleteTriggerError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return DeleteTriggerError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return DeleteTriggerError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return DeleteTriggerError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteTriggerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteTriggerError {
fn from(err: serde_json::error::Error) -> DeleteTriggerError {
DeleteTriggerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteTriggerError {
fn from(err: CredentialsError) -> DeleteTriggerError {
DeleteTriggerError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteTriggerError {
fn from(err: HttpDispatchError) -> DeleteTriggerError {
DeleteTriggerError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteTriggerError {
fn from(err: io::Error) -> DeleteTriggerError {
DeleteTriggerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteTriggerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteTriggerError {
fn description(&self) -> &str {
match *self {
DeleteTriggerError::ConcurrentModification(ref cause) => cause,
DeleteTriggerError::InternalService(ref cause) => cause,
DeleteTriggerError::InvalidInput(ref cause) => cause,
DeleteTriggerError::OperationTimeout(ref cause) => cause,
DeleteTriggerError::Validation(ref cause) => cause,
DeleteTriggerError::Credentials(ref err) => err.description(),
DeleteTriggerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteTriggerError::ParseError(ref cause) => cause,
DeleteTriggerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteUserDefinedFunctionError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteUserDefinedFunctionError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteUserDefinedFunctionError {
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 {
"EntityNotFoundException" => {
return DeleteUserDefinedFunctionError::EntityNotFound(String::from(
error_message,
))
}
"InternalServiceException" => {
return DeleteUserDefinedFunctionError::InternalService(String::from(
error_message,
))
}
"InvalidInputException" => {
return DeleteUserDefinedFunctionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return DeleteUserDefinedFunctionError::OperationTimeout(String::from(
error_message,
))
}
"ValidationException" => {
return DeleteUserDefinedFunctionError::Validation(error_message.to_string())
}
_ => {}
}
}
return DeleteUserDefinedFunctionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteUserDefinedFunctionError {
fn from(err: serde_json::error::Error) -> DeleteUserDefinedFunctionError {
DeleteUserDefinedFunctionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteUserDefinedFunctionError {
fn from(err: CredentialsError) -> DeleteUserDefinedFunctionError {
DeleteUserDefinedFunctionError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteUserDefinedFunctionError {
fn from(err: HttpDispatchError) -> DeleteUserDefinedFunctionError {
DeleteUserDefinedFunctionError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteUserDefinedFunctionError {
fn from(err: io::Error) -> DeleteUserDefinedFunctionError {
DeleteUserDefinedFunctionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteUserDefinedFunctionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteUserDefinedFunctionError {
fn description(&self) -> &str {
match *self {
DeleteUserDefinedFunctionError::EntityNotFound(ref cause) => cause,
DeleteUserDefinedFunctionError::InternalService(ref cause) => cause,
DeleteUserDefinedFunctionError::InvalidInput(ref cause) => cause,
DeleteUserDefinedFunctionError::OperationTimeout(ref cause) => cause,
DeleteUserDefinedFunctionError::Validation(ref cause) => cause,
DeleteUserDefinedFunctionError::Credentials(ref err) => err.description(),
DeleteUserDefinedFunctionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteUserDefinedFunctionError::ParseError(ref cause) => cause,
DeleteUserDefinedFunctionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetCatalogImportStatusError {
InternalService(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetCatalogImportStatusError {
pub fn from_response(res: BufferedHttpResponse) -> GetCatalogImportStatusError {
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 {
"InternalServiceException" => {
return GetCatalogImportStatusError::InternalService(String::from(error_message))
}
"OperationTimeoutException" => {
return GetCatalogImportStatusError::OperationTimeout(String::from(
error_message,
))
}
"ValidationException" => {
return GetCatalogImportStatusError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetCatalogImportStatusError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetCatalogImportStatusError {
fn from(err: serde_json::error::Error) -> GetCatalogImportStatusError {
GetCatalogImportStatusError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetCatalogImportStatusError {
fn from(err: CredentialsError) -> GetCatalogImportStatusError {
GetCatalogImportStatusError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetCatalogImportStatusError {
fn from(err: HttpDispatchError) -> GetCatalogImportStatusError {
GetCatalogImportStatusError::HttpDispatch(err)
}
}
impl From<io::Error> for GetCatalogImportStatusError {
fn from(err: io::Error) -> GetCatalogImportStatusError {
GetCatalogImportStatusError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetCatalogImportStatusError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetCatalogImportStatusError {
fn description(&self) -> &str {
match *self {
GetCatalogImportStatusError::InternalService(ref cause) => cause,
GetCatalogImportStatusError::OperationTimeout(ref cause) => cause,
GetCatalogImportStatusError::Validation(ref cause) => cause,
GetCatalogImportStatusError::Credentials(ref err) => err.description(),
GetCatalogImportStatusError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetCatalogImportStatusError::ParseError(ref cause) => cause,
GetCatalogImportStatusError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetClassifierError {
EntityNotFound(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetClassifierError {
pub fn from_response(res: BufferedHttpResponse) -> GetClassifierError {
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 {
"EntityNotFoundException" => {
return GetClassifierError::EntityNotFound(String::from(error_message))
}
"OperationTimeoutException" => {
return GetClassifierError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetClassifierError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetClassifierError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetClassifierError {
fn from(err: serde_json::error::Error) -> GetClassifierError {
GetClassifierError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetClassifierError {
fn from(err: CredentialsError) -> GetClassifierError {
GetClassifierError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetClassifierError {
fn from(err: HttpDispatchError) -> GetClassifierError {
GetClassifierError::HttpDispatch(err)
}
}
impl From<io::Error> for GetClassifierError {
fn from(err: io::Error) -> GetClassifierError {
GetClassifierError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetClassifierError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetClassifierError {
fn description(&self) -> &str {
match *self {
GetClassifierError::EntityNotFound(ref cause) => cause,
GetClassifierError::OperationTimeout(ref cause) => cause,
GetClassifierError::Validation(ref cause) => cause,
GetClassifierError::Credentials(ref err) => err.description(),
GetClassifierError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetClassifierError::ParseError(ref cause) => cause,
GetClassifierError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetClassifiersError {
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetClassifiersError {
pub fn from_response(res: BufferedHttpResponse) -> GetClassifiersError {
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 {
"OperationTimeoutException" => {
return GetClassifiersError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetClassifiersError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetClassifiersError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetClassifiersError {
fn from(err: serde_json::error::Error) -> GetClassifiersError {
GetClassifiersError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetClassifiersError {
fn from(err: CredentialsError) -> GetClassifiersError {
GetClassifiersError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetClassifiersError {
fn from(err: HttpDispatchError) -> GetClassifiersError {
GetClassifiersError::HttpDispatch(err)
}
}
impl From<io::Error> for GetClassifiersError {
fn from(err: io::Error) -> GetClassifiersError {
GetClassifiersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetClassifiersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetClassifiersError {
fn description(&self) -> &str {
match *self {
GetClassifiersError::OperationTimeout(ref cause) => cause,
GetClassifiersError::Validation(ref cause) => cause,
GetClassifiersError::Credentials(ref err) => err.description(),
GetClassifiersError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetClassifiersError::ParseError(ref cause) => cause,
GetClassifiersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetConnectionError {
EntityNotFound(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> GetConnectionError {
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 {
"EntityNotFoundException" => {
return GetConnectionError::EntityNotFound(String::from(error_message))
}
"OperationTimeoutException" => {
return GetConnectionError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetConnectionError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetConnectionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetConnectionError {
fn from(err: serde_json::error::Error) -> GetConnectionError {
GetConnectionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetConnectionError {
fn from(err: CredentialsError) -> GetConnectionError {
GetConnectionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetConnectionError {
fn from(err: HttpDispatchError) -> GetConnectionError {
GetConnectionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetConnectionError {
fn from(err: io::Error) -> GetConnectionError {
GetConnectionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetConnectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetConnectionError {
fn description(&self) -> &str {
match *self {
GetConnectionError::EntityNotFound(ref cause) => cause,
GetConnectionError::OperationTimeout(ref cause) => cause,
GetConnectionError::Validation(ref cause) => cause,
GetConnectionError::Credentials(ref err) => err.description(),
GetConnectionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetConnectionError::ParseError(ref cause) => cause,
GetConnectionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetConnectionsError {
EntityNotFound(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetConnectionsError {
pub fn from_response(res: BufferedHttpResponse) -> GetConnectionsError {
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 {
"EntityNotFoundException" => {
return GetConnectionsError::EntityNotFound(String::from(error_message))
}
"OperationTimeoutException" => {
return GetConnectionsError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetConnectionsError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetConnectionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetConnectionsError {
fn from(err: serde_json::error::Error) -> GetConnectionsError {
GetConnectionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetConnectionsError {
fn from(err: CredentialsError) -> GetConnectionsError {
GetConnectionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetConnectionsError {
fn from(err: HttpDispatchError) -> GetConnectionsError {
GetConnectionsError::HttpDispatch(err)
}
}
impl From<io::Error> for GetConnectionsError {
fn from(err: io::Error) -> GetConnectionsError {
GetConnectionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetConnectionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetConnectionsError {
fn description(&self) -> &str {
match *self {
GetConnectionsError::EntityNotFound(ref cause) => cause,
GetConnectionsError::OperationTimeout(ref cause) => cause,
GetConnectionsError::Validation(ref cause) => cause,
GetConnectionsError::Credentials(ref err) => err.description(),
GetConnectionsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetConnectionsError::ParseError(ref cause) => cause,
GetConnectionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetCrawlerError {
EntityNotFound(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetCrawlerError {
pub fn from_response(res: BufferedHttpResponse) -> GetCrawlerError {
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 {
"EntityNotFoundException" => {
return GetCrawlerError::EntityNotFound(String::from(error_message))
}
"OperationTimeoutException" => {
return GetCrawlerError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetCrawlerError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetCrawlerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetCrawlerError {
fn from(err: serde_json::error::Error) -> GetCrawlerError {
GetCrawlerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetCrawlerError {
fn from(err: CredentialsError) -> GetCrawlerError {
GetCrawlerError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetCrawlerError {
fn from(err: HttpDispatchError) -> GetCrawlerError {
GetCrawlerError::HttpDispatch(err)
}
}
impl From<io::Error> for GetCrawlerError {
fn from(err: io::Error) -> GetCrawlerError {
GetCrawlerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetCrawlerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetCrawlerError {
fn description(&self) -> &str {
match *self {
GetCrawlerError::EntityNotFound(ref cause) => cause,
GetCrawlerError::OperationTimeout(ref cause) => cause,
GetCrawlerError::Validation(ref cause) => cause,
GetCrawlerError::Credentials(ref err) => err.description(),
GetCrawlerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetCrawlerError::ParseError(ref cause) => cause,
GetCrawlerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetCrawlerMetricsError {
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetCrawlerMetricsError {
pub fn from_response(res: BufferedHttpResponse) -> GetCrawlerMetricsError {
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 {
"OperationTimeoutException" => {
return GetCrawlerMetricsError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetCrawlerMetricsError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetCrawlerMetricsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetCrawlerMetricsError {
fn from(err: serde_json::error::Error) -> GetCrawlerMetricsError {
GetCrawlerMetricsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetCrawlerMetricsError {
fn from(err: CredentialsError) -> GetCrawlerMetricsError {
GetCrawlerMetricsError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetCrawlerMetricsError {
fn from(err: HttpDispatchError) -> GetCrawlerMetricsError {
GetCrawlerMetricsError::HttpDispatch(err)
}
}
impl From<io::Error> for GetCrawlerMetricsError {
fn from(err: io::Error) -> GetCrawlerMetricsError {
GetCrawlerMetricsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetCrawlerMetricsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetCrawlerMetricsError {
fn description(&self) -> &str {
match *self {
GetCrawlerMetricsError::OperationTimeout(ref cause) => cause,
GetCrawlerMetricsError::Validation(ref cause) => cause,
GetCrawlerMetricsError::Credentials(ref err) => err.description(),
GetCrawlerMetricsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetCrawlerMetricsError::ParseError(ref cause) => cause,
GetCrawlerMetricsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetCrawlersError {
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetCrawlersError {
pub fn from_response(res: BufferedHttpResponse) -> GetCrawlersError {
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 {
"OperationTimeoutException" => {
return GetCrawlersError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetCrawlersError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetCrawlersError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetCrawlersError {
fn from(err: serde_json::error::Error) -> GetCrawlersError {
GetCrawlersError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetCrawlersError {
fn from(err: CredentialsError) -> GetCrawlersError {
GetCrawlersError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetCrawlersError {
fn from(err: HttpDispatchError) -> GetCrawlersError {
GetCrawlersError::HttpDispatch(err)
}
}
impl From<io::Error> for GetCrawlersError {
fn from(err: io::Error) -> GetCrawlersError {
GetCrawlersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetCrawlersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetCrawlersError {
fn description(&self) -> &str {
match *self {
GetCrawlersError::OperationTimeout(ref cause) => cause,
GetCrawlersError::Validation(ref cause) => cause,
GetCrawlersError::Credentials(ref err) => err.description(),
GetCrawlersError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetCrawlersError::ParseError(ref cause) => cause,
GetCrawlersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetDatabaseError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetDatabaseError {
pub fn from_response(res: BufferedHttpResponse) -> GetDatabaseError {
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 {
"EntityNotFoundException" => {
return GetDatabaseError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetDatabaseError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetDatabaseError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetDatabaseError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetDatabaseError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetDatabaseError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetDatabaseError {
fn from(err: serde_json::error::Error) -> GetDatabaseError {
GetDatabaseError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetDatabaseError {
fn from(err: CredentialsError) -> GetDatabaseError {
GetDatabaseError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetDatabaseError {
fn from(err: HttpDispatchError) -> GetDatabaseError {
GetDatabaseError::HttpDispatch(err)
}
}
impl From<io::Error> for GetDatabaseError {
fn from(err: io::Error) -> GetDatabaseError {
GetDatabaseError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetDatabaseError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetDatabaseError {
fn description(&self) -> &str {
match *self {
GetDatabaseError::EntityNotFound(ref cause) => cause,
GetDatabaseError::InternalService(ref cause) => cause,
GetDatabaseError::InvalidInput(ref cause) => cause,
GetDatabaseError::OperationTimeout(ref cause) => cause,
GetDatabaseError::Validation(ref cause) => cause,
GetDatabaseError::Credentials(ref err) => err.description(),
GetDatabaseError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetDatabaseError::ParseError(ref cause) => cause,
GetDatabaseError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetDatabasesError {
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetDatabasesError {
pub fn from_response(res: BufferedHttpResponse) -> GetDatabasesError {
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 {
"InternalServiceException" => {
return GetDatabasesError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetDatabasesError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetDatabasesError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetDatabasesError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetDatabasesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetDatabasesError {
fn from(err: serde_json::error::Error) -> GetDatabasesError {
GetDatabasesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetDatabasesError {
fn from(err: CredentialsError) -> GetDatabasesError {
GetDatabasesError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetDatabasesError {
fn from(err: HttpDispatchError) -> GetDatabasesError {
GetDatabasesError::HttpDispatch(err)
}
}
impl From<io::Error> for GetDatabasesError {
fn from(err: io::Error) -> GetDatabasesError {
GetDatabasesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetDatabasesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetDatabasesError {
fn description(&self) -> &str {
match *self {
GetDatabasesError::InternalService(ref cause) => cause,
GetDatabasesError::InvalidInput(ref cause) => cause,
GetDatabasesError::OperationTimeout(ref cause) => cause,
GetDatabasesError::Validation(ref cause) => cause,
GetDatabasesError::Credentials(ref err) => err.description(),
GetDatabasesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetDatabasesError::ParseError(ref cause) => cause,
GetDatabasesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetDataflowGraphError {
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetDataflowGraphError {
pub fn from_response(res: BufferedHttpResponse) -> GetDataflowGraphError {
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 {
"InternalServiceException" => {
return GetDataflowGraphError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetDataflowGraphError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetDataflowGraphError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetDataflowGraphError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetDataflowGraphError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetDataflowGraphError {
fn from(err: serde_json::error::Error) -> GetDataflowGraphError {
GetDataflowGraphError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetDataflowGraphError {
fn from(err: CredentialsError) -> GetDataflowGraphError {
GetDataflowGraphError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetDataflowGraphError {
fn from(err: HttpDispatchError) -> GetDataflowGraphError {
GetDataflowGraphError::HttpDispatch(err)
}
}
impl From<io::Error> for GetDataflowGraphError {
fn from(err: io::Error) -> GetDataflowGraphError {
GetDataflowGraphError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetDataflowGraphError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetDataflowGraphError {
fn description(&self) -> &str {
match *self {
GetDataflowGraphError::InternalService(ref cause) => cause,
GetDataflowGraphError::InvalidInput(ref cause) => cause,
GetDataflowGraphError::OperationTimeout(ref cause) => cause,
GetDataflowGraphError::Validation(ref cause) => cause,
GetDataflowGraphError::Credentials(ref err) => err.description(),
GetDataflowGraphError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetDataflowGraphError::ParseError(ref cause) => cause,
GetDataflowGraphError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetDevEndpointError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetDevEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> GetDevEndpointError {
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 {
"EntityNotFoundException" => {
return GetDevEndpointError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetDevEndpointError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetDevEndpointError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetDevEndpointError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetDevEndpointError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetDevEndpointError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetDevEndpointError {
fn from(err: serde_json::error::Error) -> GetDevEndpointError {
GetDevEndpointError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetDevEndpointError {
fn from(err: CredentialsError) -> GetDevEndpointError {
GetDevEndpointError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetDevEndpointError {
fn from(err: HttpDispatchError) -> GetDevEndpointError {
GetDevEndpointError::HttpDispatch(err)
}
}
impl From<io::Error> for GetDevEndpointError {
fn from(err: io::Error) -> GetDevEndpointError {
GetDevEndpointError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetDevEndpointError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetDevEndpointError {
fn description(&self) -> &str {
match *self {
GetDevEndpointError::EntityNotFound(ref cause) => cause,
GetDevEndpointError::InternalService(ref cause) => cause,
GetDevEndpointError::InvalidInput(ref cause) => cause,
GetDevEndpointError::OperationTimeout(ref cause) => cause,
GetDevEndpointError::Validation(ref cause) => cause,
GetDevEndpointError::Credentials(ref err) => err.description(),
GetDevEndpointError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetDevEndpointError::ParseError(ref cause) => cause,
GetDevEndpointError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetDevEndpointsError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetDevEndpointsError {
pub fn from_response(res: BufferedHttpResponse) -> GetDevEndpointsError {
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 {
"EntityNotFoundException" => {
return GetDevEndpointsError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetDevEndpointsError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetDevEndpointsError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetDevEndpointsError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetDevEndpointsError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetDevEndpointsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetDevEndpointsError {
fn from(err: serde_json::error::Error) -> GetDevEndpointsError {
GetDevEndpointsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetDevEndpointsError {
fn from(err: CredentialsError) -> GetDevEndpointsError {
GetDevEndpointsError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetDevEndpointsError {
fn from(err: HttpDispatchError) -> GetDevEndpointsError {
GetDevEndpointsError::HttpDispatch(err)
}
}
impl From<io::Error> for GetDevEndpointsError {
fn from(err: io::Error) -> GetDevEndpointsError {
GetDevEndpointsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetDevEndpointsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetDevEndpointsError {
fn description(&self) -> &str {
match *self {
GetDevEndpointsError::EntityNotFound(ref cause) => cause,
GetDevEndpointsError::InternalService(ref cause) => cause,
GetDevEndpointsError::InvalidInput(ref cause) => cause,
GetDevEndpointsError::OperationTimeout(ref cause) => cause,
GetDevEndpointsError::Validation(ref cause) => cause,
GetDevEndpointsError::Credentials(ref err) => err.description(),
GetDevEndpointsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetDevEndpointsError::ParseError(ref cause) => cause,
GetDevEndpointsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetJobError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetJobError {
pub fn from_response(res: BufferedHttpResponse) -> GetJobError {
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 {
"EntityNotFoundException" => {
return GetJobError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetJobError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetJobError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetJobError::OperationTimeout(String::from(error_message))
}
"ValidationException" => return GetJobError::Validation(error_message.to_string()),
_ => {}
}
}
return GetJobError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetJobError {
fn from(err: serde_json::error::Error) -> GetJobError {
GetJobError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetJobError {
fn from(err: CredentialsError) -> GetJobError {
GetJobError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetJobError {
fn from(err: HttpDispatchError) -> GetJobError {
GetJobError::HttpDispatch(err)
}
}
impl From<io::Error> for GetJobError {
fn from(err: io::Error) -> GetJobError {
GetJobError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetJobError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetJobError {
fn description(&self) -> &str {
match *self {
GetJobError::EntityNotFound(ref cause) => cause,
GetJobError::InternalService(ref cause) => cause,
GetJobError::InvalidInput(ref cause) => cause,
GetJobError::OperationTimeout(ref cause) => cause,
GetJobError::Validation(ref cause) => cause,
GetJobError::Credentials(ref err) => err.description(),
GetJobError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetJobError::ParseError(ref cause) => cause,
GetJobError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetJobRunError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetJobRunError {
pub fn from_response(res: BufferedHttpResponse) -> GetJobRunError {
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 {
"EntityNotFoundException" => {
return GetJobRunError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetJobRunError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetJobRunError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetJobRunError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetJobRunError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetJobRunError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetJobRunError {
fn from(err: serde_json::error::Error) -> GetJobRunError {
GetJobRunError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetJobRunError {
fn from(err: CredentialsError) -> GetJobRunError {
GetJobRunError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetJobRunError {
fn from(err: HttpDispatchError) -> GetJobRunError {
GetJobRunError::HttpDispatch(err)
}
}
impl From<io::Error> for GetJobRunError {
fn from(err: io::Error) -> GetJobRunError {
GetJobRunError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetJobRunError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetJobRunError {
fn description(&self) -> &str {
match *self {
GetJobRunError::EntityNotFound(ref cause) => cause,
GetJobRunError::InternalService(ref cause) => cause,
GetJobRunError::InvalidInput(ref cause) => cause,
GetJobRunError::OperationTimeout(ref cause) => cause,
GetJobRunError::Validation(ref cause) => cause,
GetJobRunError::Credentials(ref err) => err.description(),
GetJobRunError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetJobRunError::ParseError(ref cause) => cause,
GetJobRunError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetJobRunsError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetJobRunsError {
pub fn from_response(res: BufferedHttpResponse) -> GetJobRunsError {
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 {
"EntityNotFoundException" => {
return GetJobRunsError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetJobRunsError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetJobRunsError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetJobRunsError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetJobRunsError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetJobRunsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetJobRunsError {
fn from(err: serde_json::error::Error) -> GetJobRunsError {
GetJobRunsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetJobRunsError {
fn from(err: CredentialsError) -> GetJobRunsError {
GetJobRunsError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetJobRunsError {
fn from(err: HttpDispatchError) -> GetJobRunsError {
GetJobRunsError::HttpDispatch(err)
}
}
impl From<io::Error> for GetJobRunsError {
fn from(err: io::Error) -> GetJobRunsError {
GetJobRunsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetJobRunsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetJobRunsError {
fn description(&self) -> &str {
match *self {
GetJobRunsError::EntityNotFound(ref cause) => cause,
GetJobRunsError::InternalService(ref cause) => cause,
GetJobRunsError::InvalidInput(ref cause) => cause,
GetJobRunsError::OperationTimeout(ref cause) => cause,
GetJobRunsError::Validation(ref cause) => cause,
GetJobRunsError::Credentials(ref err) => err.description(),
GetJobRunsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetJobRunsError::ParseError(ref cause) => cause,
GetJobRunsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetJobsError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetJobsError {
pub fn from_response(res: BufferedHttpResponse) -> GetJobsError {
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 {
"EntityNotFoundException" => {
return GetJobsError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetJobsError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetJobsError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetJobsError::OperationTimeout(String::from(error_message))
}
"ValidationException" => return GetJobsError::Validation(error_message.to_string()),
_ => {}
}
}
return GetJobsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetJobsError {
fn from(err: serde_json::error::Error) -> GetJobsError {
GetJobsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetJobsError {
fn from(err: CredentialsError) -> GetJobsError {
GetJobsError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetJobsError {
fn from(err: HttpDispatchError) -> GetJobsError {
GetJobsError::HttpDispatch(err)
}
}
impl From<io::Error> for GetJobsError {
fn from(err: io::Error) -> GetJobsError {
GetJobsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetJobsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetJobsError {
fn description(&self) -> &str {
match *self {
GetJobsError::EntityNotFound(ref cause) => cause,
GetJobsError::InternalService(ref cause) => cause,
GetJobsError::InvalidInput(ref cause) => cause,
GetJobsError::OperationTimeout(ref cause) => cause,
GetJobsError::Validation(ref cause) => cause,
GetJobsError::Credentials(ref err) => err.description(),
GetJobsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetJobsError::ParseError(ref cause) => cause,
GetJobsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetMappingError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetMappingError {
pub fn from_response(res: BufferedHttpResponse) -> GetMappingError {
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 {
"EntityNotFoundException" => {
return GetMappingError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetMappingError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetMappingError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetMappingError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetMappingError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetMappingError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetMappingError {
fn from(err: serde_json::error::Error) -> GetMappingError {
GetMappingError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetMappingError {
fn from(err: CredentialsError) -> GetMappingError {
GetMappingError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetMappingError {
fn from(err: HttpDispatchError) -> GetMappingError {
GetMappingError::HttpDispatch(err)
}
}
impl From<io::Error> for GetMappingError {
fn from(err: io::Error) -> GetMappingError {
GetMappingError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetMappingError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetMappingError {
fn description(&self) -> &str {
match *self {
GetMappingError::EntityNotFound(ref cause) => cause,
GetMappingError::InternalService(ref cause) => cause,
GetMappingError::InvalidInput(ref cause) => cause,
GetMappingError::OperationTimeout(ref cause) => cause,
GetMappingError::Validation(ref cause) => cause,
GetMappingError::Credentials(ref err) => err.description(),
GetMappingError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetMappingError::ParseError(ref cause) => cause,
GetMappingError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetPartitionError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetPartitionError {
pub fn from_response(res: BufferedHttpResponse) -> GetPartitionError {
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 {
"EntityNotFoundException" => {
return GetPartitionError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetPartitionError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetPartitionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetPartitionError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetPartitionError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetPartitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetPartitionError {
fn from(err: serde_json::error::Error) -> GetPartitionError {
GetPartitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetPartitionError {
fn from(err: CredentialsError) -> GetPartitionError {
GetPartitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetPartitionError {
fn from(err: HttpDispatchError) -> GetPartitionError {
GetPartitionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetPartitionError {
fn from(err: io::Error) -> GetPartitionError {
GetPartitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetPartitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetPartitionError {
fn description(&self) -> &str {
match *self {
GetPartitionError::EntityNotFound(ref cause) => cause,
GetPartitionError::InternalService(ref cause) => cause,
GetPartitionError::InvalidInput(ref cause) => cause,
GetPartitionError::OperationTimeout(ref cause) => cause,
GetPartitionError::Validation(ref cause) => cause,
GetPartitionError::Credentials(ref err) => err.description(),
GetPartitionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetPartitionError::ParseError(ref cause) => cause,
GetPartitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetPartitionsError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetPartitionsError {
pub fn from_response(res: BufferedHttpResponse) -> GetPartitionsError {
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 {
"EntityNotFoundException" => {
return GetPartitionsError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetPartitionsError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetPartitionsError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetPartitionsError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetPartitionsError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetPartitionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetPartitionsError {
fn from(err: serde_json::error::Error) -> GetPartitionsError {
GetPartitionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetPartitionsError {
fn from(err: CredentialsError) -> GetPartitionsError {
GetPartitionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetPartitionsError {
fn from(err: HttpDispatchError) -> GetPartitionsError {
GetPartitionsError::HttpDispatch(err)
}
}
impl From<io::Error> for GetPartitionsError {
fn from(err: io::Error) -> GetPartitionsError {
GetPartitionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetPartitionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetPartitionsError {
fn description(&self) -> &str {
match *self {
GetPartitionsError::EntityNotFound(ref cause) => cause,
GetPartitionsError::InternalService(ref cause) => cause,
GetPartitionsError::InvalidInput(ref cause) => cause,
GetPartitionsError::OperationTimeout(ref cause) => cause,
GetPartitionsError::Validation(ref cause) => cause,
GetPartitionsError::Credentials(ref err) => err.description(),
GetPartitionsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetPartitionsError::ParseError(ref cause) => cause,
GetPartitionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetPlanError {
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetPlanError {
pub fn from_response(res: BufferedHttpResponse) -> GetPlanError {
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 {
"InternalServiceException" => {
return GetPlanError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetPlanError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetPlanError::OperationTimeout(String::from(error_message))
}
"ValidationException" => return GetPlanError::Validation(error_message.to_string()),
_ => {}
}
}
return GetPlanError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetPlanError {
fn from(err: serde_json::error::Error) -> GetPlanError {
GetPlanError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetPlanError {
fn from(err: CredentialsError) -> GetPlanError {
GetPlanError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetPlanError {
fn from(err: HttpDispatchError) -> GetPlanError {
GetPlanError::HttpDispatch(err)
}
}
impl From<io::Error> for GetPlanError {
fn from(err: io::Error) -> GetPlanError {
GetPlanError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetPlanError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetPlanError {
fn description(&self) -> &str {
match *self {
GetPlanError::InternalService(ref cause) => cause,
GetPlanError::InvalidInput(ref cause) => cause,
GetPlanError::OperationTimeout(ref cause) => cause,
GetPlanError::Validation(ref cause) => cause,
GetPlanError::Credentials(ref err) => err.description(),
GetPlanError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetPlanError::ParseError(ref cause) => cause,
GetPlanError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetTableError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetTableError {
pub fn from_response(res: BufferedHttpResponse) -> GetTableError {
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 {
"EntityNotFoundException" => {
return GetTableError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetTableError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetTableError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetTableError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetTableError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetTableError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetTableError {
fn from(err: serde_json::error::Error) -> GetTableError {
GetTableError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetTableError {
fn from(err: CredentialsError) -> GetTableError {
GetTableError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetTableError {
fn from(err: HttpDispatchError) -> GetTableError {
GetTableError::HttpDispatch(err)
}
}
impl From<io::Error> for GetTableError {
fn from(err: io::Error) -> GetTableError {
GetTableError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetTableError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetTableError {
fn description(&self) -> &str {
match *self {
GetTableError::EntityNotFound(ref cause) => cause,
GetTableError::InternalService(ref cause) => cause,
GetTableError::InvalidInput(ref cause) => cause,
GetTableError::OperationTimeout(ref cause) => cause,
GetTableError::Validation(ref cause) => cause,
GetTableError::Credentials(ref err) => err.description(),
GetTableError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetTableError::ParseError(ref cause) => cause,
GetTableError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetTableVersionError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetTableVersionError {
pub fn from_response(res: BufferedHttpResponse) -> GetTableVersionError {
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 {
"EntityNotFoundException" => {
return GetTableVersionError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetTableVersionError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetTableVersionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetTableVersionError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetTableVersionError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetTableVersionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetTableVersionError {
fn from(err: serde_json::error::Error) -> GetTableVersionError {
GetTableVersionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetTableVersionError {
fn from(err: CredentialsError) -> GetTableVersionError {
GetTableVersionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetTableVersionError {
fn from(err: HttpDispatchError) -> GetTableVersionError {
GetTableVersionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetTableVersionError {
fn from(err: io::Error) -> GetTableVersionError {
GetTableVersionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetTableVersionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetTableVersionError {
fn description(&self) -> &str {
match *self {
GetTableVersionError::EntityNotFound(ref cause) => cause,
GetTableVersionError::InternalService(ref cause) => cause,
GetTableVersionError::InvalidInput(ref cause) => cause,
GetTableVersionError::OperationTimeout(ref cause) => cause,
GetTableVersionError::Validation(ref cause) => cause,
GetTableVersionError::Credentials(ref err) => err.description(),
GetTableVersionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetTableVersionError::ParseError(ref cause) => cause,
GetTableVersionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetTableVersionsError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetTableVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> GetTableVersionsError {
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 {
"EntityNotFoundException" => {
return GetTableVersionsError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetTableVersionsError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetTableVersionsError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetTableVersionsError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetTableVersionsError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetTableVersionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetTableVersionsError {
fn from(err: serde_json::error::Error) -> GetTableVersionsError {
GetTableVersionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetTableVersionsError {
fn from(err: CredentialsError) -> GetTableVersionsError {
GetTableVersionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetTableVersionsError {
fn from(err: HttpDispatchError) -> GetTableVersionsError {
GetTableVersionsError::HttpDispatch(err)
}
}
impl From<io::Error> for GetTableVersionsError {
fn from(err: io::Error) -> GetTableVersionsError {
GetTableVersionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetTableVersionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetTableVersionsError {
fn description(&self) -> &str {
match *self {
GetTableVersionsError::EntityNotFound(ref cause) => cause,
GetTableVersionsError::InternalService(ref cause) => cause,
GetTableVersionsError::InvalidInput(ref cause) => cause,
GetTableVersionsError::OperationTimeout(ref cause) => cause,
GetTableVersionsError::Validation(ref cause) => cause,
GetTableVersionsError::Credentials(ref err) => err.description(),
GetTableVersionsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetTableVersionsError::ParseError(ref cause) => cause,
GetTableVersionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetTablesError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetTablesError {
pub fn from_response(res: BufferedHttpResponse) -> GetTablesError {
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 {
"EntityNotFoundException" => {
return GetTablesError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetTablesError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetTablesError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetTablesError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetTablesError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetTablesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetTablesError {
fn from(err: serde_json::error::Error) -> GetTablesError {
GetTablesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetTablesError {
fn from(err: CredentialsError) -> GetTablesError {
GetTablesError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetTablesError {
fn from(err: HttpDispatchError) -> GetTablesError {
GetTablesError::HttpDispatch(err)
}
}
impl From<io::Error> for GetTablesError {
fn from(err: io::Error) -> GetTablesError {
GetTablesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetTablesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetTablesError {
fn description(&self) -> &str {
match *self {
GetTablesError::EntityNotFound(ref cause) => cause,
GetTablesError::InternalService(ref cause) => cause,
GetTablesError::InvalidInput(ref cause) => cause,
GetTablesError::OperationTimeout(ref cause) => cause,
GetTablesError::Validation(ref cause) => cause,
GetTablesError::Credentials(ref err) => err.description(),
GetTablesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetTablesError::ParseError(ref cause) => cause,
GetTablesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetTriggerError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetTriggerError {
pub fn from_response(res: BufferedHttpResponse) -> GetTriggerError {
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 {
"EntityNotFoundException" => {
return GetTriggerError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetTriggerError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetTriggerError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetTriggerError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetTriggerError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetTriggerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetTriggerError {
fn from(err: serde_json::error::Error) -> GetTriggerError {
GetTriggerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetTriggerError {
fn from(err: CredentialsError) -> GetTriggerError {
GetTriggerError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetTriggerError {
fn from(err: HttpDispatchError) -> GetTriggerError {
GetTriggerError::HttpDispatch(err)
}
}
impl From<io::Error> for GetTriggerError {
fn from(err: io::Error) -> GetTriggerError {
GetTriggerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetTriggerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetTriggerError {
fn description(&self) -> &str {
match *self {
GetTriggerError::EntityNotFound(ref cause) => cause,
GetTriggerError::InternalService(ref cause) => cause,
GetTriggerError::InvalidInput(ref cause) => cause,
GetTriggerError::OperationTimeout(ref cause) => cause,
GetTriggerError::Validation(ref cause) => cause,
GetTriggerError::Credentials(ref err) => err.description(),
GetTriggerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetTriggerError::ParseError(ref cause) => cause,
GetTriggerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetTriggersError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetTriggersError {
pub fn from_response(res: BufferedHttpResponse) -> GetTriggersError {
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 {
"EntityNotFoundException" => {
return GetTriggersError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetTriggersError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetTriggersError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetTriggersError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return GetTriggersError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetTriggersError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetTriggersError {
fn from(err: serde_json::error::Error) -> GetTriggersError {
GetTriggersError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetTriggersError {
fn from(err: CredentialsError) -> GetTriggersError {
GetTriggersError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetTriggersError {
fn from(err: HttpDispatchError) -> GetTriggersError {
GetTriggersError::HttpDispatch(err)
}
}
impl From<io::Error> for GetTriggersError {
fn from(err: io::Error) -> GetTriggersError {
GetTriggersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetTriggersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetTriggersError {
fn description(&self) -> &str {
match *self {
GetTriggersError::EntityNotFound(ref cause) => cause,
GetTriggersError::InternalService(ref cause) => cause,
GetTriggersError::InvalidInput(ref cause) => cause,
GetTriggersError::OperationTimeout(ref cause) => cause,
GetTriggersError::Validation(ref cause) => cause,
GetTriggersError::Credentials(ref err) => err.description(),
GetTriggersError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
GetTriggersError::ParseError(ref cause) => cause,
GetTriggersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetUserDefinedFunctionError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetUserDefinedFunctionError {
pub fn from_response(res: BufferedHttpResponse) -> GetUserDefinedFunctionError {
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 {
"EntityNotFoundException" => {
return GetUserDefinedFunctionError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetUserDefinedFunctionError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return GetUserDefinedFunctionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetUserDefinedFunctionError::OperationTimeout(String::from(
error_message,
))
}
"ValidationException" => {
return GetUserDefinedFunctionError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetUserDefinedFunctionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetUserDefinedFunctionError {
fn from(err: serde_json::error::Error) -> GetUserDefinedFunctionError {
GetUserDefinedFunctionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetUserDefinedFunctionError {
fn from(err: CredentialsError) -> GetUserDefinedFunctionError {
GetUserDefinedFunctionError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetUserDefinedFunctionError {
fn from(err: HttpDispatchError) -> GetUserDefinedFunctionError {
GetUserDefinedFunctionError::HttpDispatch(err)
}
}
impl From<io::Error> for GetUserDefinedFunctionError {
fn from(err: io::Error) -> GetUserDefinedFunctionError {
GetUserDefinedFunctionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetUserDefinedFunctionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetUserDefinedFunctionError {
fn description(&self) -> &str {
match *self {
GetUserDefinedFunctionError::EntityNotFound(ref cause) => cause,
GetUserDefinedFunctionError::InternalService(ref cause) => cause,
GetUserDefinedFunctionError::InvalidInput(ref cause) => cause,
GetUserDefinedFunctionError::OperationTimeout(ref cause) => cause,
GetUserDefinedFunctionError::Validation(ref cause) => cause,
GetUserDefinedFunctionError::Credentials(ref err) => err.description(),
GetUserDefinedFunctionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetUserDefinedFunctionError::ParseError(ref cause) => cause,
GetUserDefinedFunctionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetUserDefinedFunctionsError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetUserDefinedFunctionsError {
pub fn from_response(res: BufferedHttpResponse) -> GetUserDefinedFunctionsError {
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 {
"EntityNotFoundException" => {
return GetUserDefinedFunctionsError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return GetUserDefinedFunctionsError::InternalService(String::from(
error_message,
))
}
"InvalidInputException" => {
return GetUserDefinedFunctionsError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return GetUserDefinedFunctionsError::OperationTimeout(String::from(
error_message,
))
}
"ValidationException" => {
return GetUserDefinedFunctionsError::Validation(error_message.to_string())
}
_ => {}
}
}
return GetUserDefinedFunctionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetUserDefinedFunctionsError {
fn from(err: serde_json::error::Error) -> GetUserDefinedFunctionsError {
GetUserDefinedFunctionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetUserDefinedFunctionsError {
fn from(err: CredentialsError) -> GetUserDefinedFunctionsError {
GetUserDefinedFunctionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetUserDefinedFunctionsError {
fn from(err: HttpDispatchError) -> GetUserDefinedFunctionsError {
GetUserDefinedFunctionsError::HttpDispatch(err)
}
}
impl From<io::Error> for GetUserDefinedFunctionsError {
fn from(err: io::Error) -> GetUserDefinedFunctionsError {
GetUserDefinedFunctionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetUserDefinedFunctionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetUserDefinedFunctionsError {
fn description(&self) -> &str {
match *self {
GetUserDefinedFunctionsError::EntityNotFound(ref cause) => cause,
GetUserDefinedFunctionsError::InternalService(ref cause) => cause,
GetUserDefinedFunctionsError::InvalidInput(ref cause) => cause,
GetUserDefinedFunctionsError::OperationTimeout(ref cause) => cause,
GetUserDefinedFunctionsError::Validation(ref cause) => cause,
GetUserDefinedFunctionsError::Credentials(ref err) => err.description(),
GetUserDefinedFunctionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetUserDefinedFunctionsError::ParseError(ref cause) => cause,
GetUserDefinedFunctionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ImportCatalogToGlueError {
InternalService(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ImportCatalogToGlueError {
pub fn from_response(res: BufferedHttpResponse) -> ImportCatalogToGlueError {
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 {
"InternalServiceException" => {
return ImportCatalogToGlueError::InternalService(String::from(error_message))
}
"OperationTimeoutException" => {
return ImportCatalogToGlueError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return ImportCatalogToGlueError::Validation(error_message.to_string())
}
_ => {}
}
}
return ImportCatalogToGlueError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ImportCatalogToGlueError {
fn from(err: serde_json::error::Error) -> ImportCatalogToGlueError {
ImportCatalogToGlueError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ImportCatalogToGlueError {
fn from(err: CredentialsError) -> ImportCatalogToGlueError {
ImportCatalogToGlueError::Credentials(err)
}
}
impl From<HttpDispatchError> for ImportCatalogToGlueError {
fn from(err: HttpDispatchError) -> ImportCatalogToGlueError {
ImportCatalogToGlueError::HttpDispatch(err)
}
}
impl From<io::Error> for ImportCatalogToGlueError {
fn from(err: io::Error) -> ImportCatalogToGlueError {
ImportCatalogToGlueError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ImportCatalogToGlueError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ImportCatalogToGlueError {
fn description(&self) -> &str {
match *self {
ImportCatalogToGlueError::InternalService(ref cause) => cause,
ImportCatalogToGlueError::OperationTimeout(ref cause) => cause,
ImportCatalogToGlueError::Validation(ref cause) => cause,
ImportCatalogToGlueError::Credentials(ref err) => err.description(),
ImportCatalogToGlueError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ImportCatalogToGlueError::ParseError(ref cause) => cause,
ImportCatalogToGlueError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ResetJobBookmarkError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ResetJobBookmarkError {
pub fn from_response(res: BufferedHttpResponse) -> ResetJobBookmarkError {
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 {
"EntityNotFoundException" => {
return ResetJobBookmarkError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return ResetJobBookmarkError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return ResetJobBookmarkError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return ResetJobBookmarkError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return ResetJobBookmarkError::Validation(error_message.to_string())
}
_ => {}
}
}
return ResetJobBookmarkError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ResetJobBookmarkError {
fn from(err: serde_json::error::Error) -> ResetJobBookmarkError {
ResetJobBookmarkError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ResetJobBookmarkError {
fn from(err: CredentialsError) -> ResetJobBookmarkError {
ResetJobBookmarkError::Credentials(err)
}
}
impl From<HttpDispatchError> for ResetJobBookmarkError {
fn from(err: HttpDispatchError) -> ResetJobBookmarkError {
ResetJobBookmarkError::HttpDispatch(err)
}
}
impl From<io::Error> for ResetJobBookmarkError {
fn from(err: io::Error) -> ResetJobBookmarkError {
ResetJobBookmarkError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ResetJobBookmarkError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResetJobBookmarkError {
fn description(&self) -> &str {
match *self {
ResetJobBookmarkError::EntityNotFound(ref cause) => cause,
ResetJobBookmarkError::InternalService(ref cause) => cause,
ResetJobBookmarkError::InvalidInput(ref cause) => cause,
ResetJobBookmarkError::OperationTimeout(ref cause) => cause,
ResetJobBookmarkError::Validation(ref cause) => cause,
ResetJobBookmarkError::Credentials(ref err) => err.description(),
ResetJobBookmarkError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ResetJobBookmarkError::ParseError(ref cause) => cause,
ResetJobBookmarkError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartCrawlerError {
CrawlerRunning(String),
EntityNotFound(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartCrawlerError {
pub fn from_response(res: BufferedHttpResponse) -> StartCrawlerError {
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 {
"CrawlerRunningException" => {
return StartCrawlerError::CrawlerRunning(String::from(error_message))
}
"EntityNotFoundException" => {
return StartCrawlerError::EntityNotFound(String::from(error_message))
}
"OperationTimeoutException" => {
return StartCrawlerError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return StartCrawlerError::Validation(error_message.to_string())
}
_ => {}
}
}
return StartCrawlerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartCrawlerError {
fn from(err: serde_json::error::Error) -> StartCrawlerError {
StartCrawlerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartCrawlerError {
fn from(err: CredentialsError) -> StartCrawlerError {
StartCrawlerError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartCrawlerError {
fn from(err: HttpDispatchError) -> StartCrawlerError {
StartCrawlerError::HttpDispatch(err)
}
}
impl From<io::Error> for StartCrawlerError {
fn from(err: io::Error) -> StartCrawlerError {
StartCrawlerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartCrawlerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartCrawlerError {
fn description(&self) -> &str {
match *self {
StartCrawlerError::CrawlerRunning(ref cause) => cause,
StartCrawlerError::EntityNotFound(ref cause) => cause,
StartCrawlerError::OperationTimeout(ref cause) => cause,
StartCrawlerError::Validation(ref cause) => cause,
StartCrawlerError::Credentials(ref err) => err.description(),
StartCrawlerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StartCrawlerError::ParseError(ref cause) => cause,
StartCrawlerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartCrawlerScheduleError {
EntityNotFound(String),
NoSchedule(String),
OperationTimeout(String),
SchedulerRunning(String),
SchedulerTransitioning(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartCrawlerScheduleError {
pub fn from_response(res: BufferedHttpResponse) -> StartCrawlerScheduleError {
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 {
"EntityNotFoundException" => {
return StartCrawlerScheduleError::EntityNotFound(String::from(error_message))
}
"NoScheduleException" => {
return StartCrawlerScheduleError::NoSchedule(String::from(error_message))
}
"OperationTimeoutException" => {
return StartCrawlerScheduleError::OperationTimeout(String::from(error_message))
}
"SchedulerRunningException" => {
return StartCrawlerScheduleError::SchedulerRunning(String::from(error_message))
}
"SchedulerTransitioningException" => {
return StartCrawlerScheduleError::SchedulerTransitioning(String::from(
error_message,
))
}
"ValidationException" => {
return StartCrawlerScheduleError::Validation(error_message.to_string())
}
_ => {}
}
}
return StartCrawlerScheduleError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartCrawlerScheduleError {
fn from(err: serde_json::error::Error) -> StartCrawlerScheduleError {
StartCrawlerScheduleError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartCrawlerScheduleError {
fn from(err: CredentialsError) -> StartCrawlerScheduleError {
StartCrawlerScheduleError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartCrawlerScheduleError {
fn from(err: HttpDispatchError) -> StartCrawlerScheduleError {
StartCrawlerScheduleError::HttpDispatch(err)
}
}
impl From<io::Error> for StartCrawlerScheduleError {
fn from(err: io::Error) -> StartCrawlerScheduleError {
StartCrawlerScheduleError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartCrawlerScheduleError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartCrawlerScheduleError {
fn description(&self) -> &str {
match *self {
StartCrawlerScheduleError::EntityNotFound(ref cause) => cause,
StartCrawlerScheduleError::NoSchedule(ref cause) => cause,
StartCrawlerScheduleError::OperationTimeout(ref cause) => cause,
StartCrawlerScheduleError::SchedulerRunning(ref cause) => cause,
StartCrawlerScheduleError::SchedulerTransitioning(ref cause) => cause,
StartCrawlerScheduleError::Validation(ref cause) => cause,
StartCrawlerScheduleError::Credentials(ref err) => err.description(),
StartCrawlerScheduleError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
StartCrawlerScheduleError::ParseError(ref cause) => cause,
StartCrawlerScheduleError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartJobRunError {
ConcurrentRunsExceeded(String),
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
ResourceNumberLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartJobRunError {
pub fn from_response(res: BufferedHttpResponse) -> StartJobRunError {
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 {
"ConcurrentRunsExceededException" => {
return StartJobRunError::ConcurrentRunsExceeded(String::from(error_message))
}
"EntityNotFoundException" => {
return StartJobRunError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return StartJobRunError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return StartJobRunError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return StartJobRunError::OperationTimeout(String::from(error_message))
}
"ResourceNumberLimitExceededException" => {
return StartJobRunError::ResourceNumberLimitExceeded(String::from(
error_message,
))
}
"ValidationException" => {
return StartJobRunError::Validation(error_message.to_string())
}
_ => {}
}
}
return StartJobRunError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartJobRunError {
fn from(err: serde_json::error::Error) -> StartJobRunError {
StartJobRunError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartJobRunError {
fn from(err: CredentialsError) -> StartJobRunError {
StartJobRunError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartJobRunError {
fn from(err: HttpDispatchError) -> StartJobRunError {
StartJobRunError::HttpDispatch(err)
}
}
impl From<io::Error> for StartJobRunError {
fn from(err: io::Error) -> StartJobRunError {
StartJobRunError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartJobRunError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartJobRunError {
fn description(&self) -> &str {
match *self {
StartJobRunError::ConcurrentRunsExceeded(ref cause) => cause,
StartJobRunError::EntityNotFound(ref cause) => cause,
StartJobRunError::InternalService(ref cause) => cause,
StartJobRunError::InvalidInput(ref cause) => cause,
StartJobRunError::OperationTimeout(ref cause) => cause,
StartJobRunError::ResourceNumberLimitExceeded(ref cause) => cause,
StartJobRunError::Validation(ref cause) => cause,
StartJobRunError::Credentials(ref err) => err.description(),
StartJobRunError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StartJobRunError::ParseError(ref cause) => cause,
StartJobRunError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartTriggerError {
ConcurrentRunsExceeded(String),
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
ResourceNumberLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartTriggerError {
pub fn from_response(res: BufferedHttpResponse) -> StartTriggerError {
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 {
"ConcurrentRunsExceededException" => {
return StartTriggerError::ConcurrentRunsExceeded(String::from(error_message))
}
"EntityNotFoundException" => {
return StartTriggerError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return StartTriggerError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return StartTriggerError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return StartTriggerError::OperationTimeout(String::from(error_message))
}
"ResourceNumberLimitExceededException" => {
return StartTriggerError::ResourceNumberLimitExceeded(String::from(
error_message,
))
}
"ValidationException" => {
return StartTriggerError::Validation(error_message.to_string())
}
_ => {}
}
}
return StartTriggerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartTriggerError {
fn from(err: serde_json::error::Error) -> StartTriggerError {
StartTriggerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartTriggerError {
fn from(err: CredentialsError) -> StartTriggerError {
StartTriggerError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartTriggerError {
fn from(err: HttpDispatchError) -> StartTriggerError {
StartTriggerError::HttpDispatch(err)
}
}
impl From<io::Error> for StartTriggerError {
fn from(err: io::Error) -> StartTriggerError {
StartTriggerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartTriggerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartTriggerError {
fn description(&self) -> &str {
match *self {
StartTriggerError::ConcurrentRunsExceeded(ref cause) => cause,
StartTriggerError::EntityNotFound(ref cause) => cause,
StartTriggerError::InternalService(ref cause) => cause,
StartTriggerError::InvalidInput(ref cause) => cause,
StartTriggerError::OperationTimeout(ref cause) => cause,
StartTriggerError::ResourceNumberLimitExceeded(ref cause) => cause,
StartTriggerError::Validation(ref cause) => cause,
StartTriggerError::Credentials(ref err) => err.description(),
StartTriggerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StartTriggerError::ParseError(ref cause) => cause,
StartTriggerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StopCrawlerError {
CrawlerNotRunning(String),
CrawlerStopping(String),
EntityNotFound(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StopCrawlerError {
pub fn from_response(res: BufferedHttpResponse) -> StopCrawlerError {
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 {
"CrawlerNotRunningException" => {
return StopCrawlerError::CrawlerNotRunning(String::from(error_message))
}
"CrawlerStoppingException" => {
return StopCrawlerError::CrawlerStopping(String::from(error_message))
}
"EntityNotFoundException" => {
return StopCrawlerError::EntityNotFound(String::from(error_message))
}
"OperationTimeoutException" => {
return StopCrawlerError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return StopCrawlerError::Validation(error_message.to_string())
}
_ => {}
}
}
return StopCrawlerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StopCrawlerError {
fn from(err: serde_json::error::Error) -> StopCrawlerError {
StopCrawlerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StopCrawlerError {
fn from(err: CredentialsError) -> StopCrawlerError {
StopCrawlerError::Credentials(err)
}
}
impl From<HttpDispatchError> for StopCrawlerError {
fn from(err: HttpDispatchError) -> StopCrawlerError {
StopCrawlerError::HttpDispatch(err)
}
}
impl From<io::Error> for StopCrawlerError {
fn from(err: io::Error) -> StopCrawlerError {
StopCrawlerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StopCrawlerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StopCrawlerError {
fn description(&self) -> &str {
match *self {
StopCrawlerError::CrawlerNotRunning(ref cause) => cause,
StopCrawlerError::CrawlerStopping(ref cause) => cause,
StopCrawlerError::EntityNotFound(ref cause) => cause,
StopCrawlerError::OperationTimeout(ref cause) => cause,
StopCrawlerError::Validation(ref cause) => cause,
StopCrawlerError::Credentials(ref err) => err.description(),
StopCrawlerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StopCrawlerError::ParseError(ref cause) => cause,
StopCrawlerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StopCrawlerScheduleError {
EntityNotFound(String),
OperationTimeout(String),
SchedulerNotRunning(String),
SchedulerTransitioning(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StopCrawlerScheduleError {
pub fn from_response(res: BufferedHttpResponse) -> StopCrawlerScheduleError {
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 {
"EntityNotFoundException" => {
return StopCrawlerScheduleError::EntityNotFound(String::from(error_message))
}
"OperationTimeoutException" => {
return StopCrawlerScheduleError::OperationTimeout(String::from(error_message))
}
"SchedulerNotRunningException" => {
return StopCrawlerScheduleError::SchedulerNotRunning(String::from(
error_message,
))
}
"SchedulerTransitioningException" => {
return StopCrawlerScheduleError::SchedulerTransitioning(String::from(
error_message,
))
}
"ValidationException" => {
return StopCrawlerScheduleError::Validation(error_message.to_string())
}
_ => {}
}
}
return StopCrawlerScheduleError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StopCrawlerScheduleError {
fn from(err: serde_json::error::Error) -> StopCrawlerScheduleError {
StopCrawlerScheduleError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StopCrawlerScheduleError {
fn from(err: CredentialsError) -> StopCrawlerScheduleError {
StopCrawlerScheduleError::Credentials(err)
}
}
impl From<HttpDispatchError> for StopCrawlerScheduleError {
fn from(err: HttpDispatchError) -> StopCrawlerScheduleError {
StopCrawlerScheduleError::HttpDispatch(err)
}
}
impl From<io::Error> for StopCrawlerScheduleError {
fn from(err: io::Error) -> StopCrawlerScheduleError {
StopCrawlerScheduleError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StopCrawlerScheduleError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StopCrawlerScheduleError {
fn description(&self) -> &str {
match *self {
StopCrawlerScheduleError::EntityNotFound(ref cause) => cause,
StopCrawlerScheduleError::OperationTimeout(ref cause) => cause,
StopCrawlerScheduleError::SchedulerNotRunning(ref cause) => cause,
StopCrawlerScheduleError::SchedulerTransitioning(ref cause) => cause,
StopCrawlerScheduleError::Validation(ref cause) => cause,
StopCrawlerScheduleError::Credentials(ref err) => err.description(),
StopCrawlerScheduleError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
StopCrawlerScheduleError::ParseError(ref cause) => cause,
StopCrawlerScheduleError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StopTriggerError {
ConcurrentModification(String),
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StopTriggerError {
pub fn from_response(res: BufferedHttpResponse) -> StopTriggerError {
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 StopTriggerError::ConcurrentModification(String::from(error_message))
}
"EntityNotFoundException" => {
return StopTriggerError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return StopTriggerError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return StopTriggerError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return StopTriggerError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return StopTriggerError::Validation(error_message.to_string())
}
_ => {}
}
}
return StopTriggerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StopTriggerError {
fn from(err: serde_json::error::Error) -> StopTriggerError {
StopTriggerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StopTriggerError {
fn from(err: CredentialsError) -> StopTriggerError {
StopTriggerError::Credentials(err)
}
}
impl From<HttpDispatchError> for StopTriggerError {
fn from(err: HttpDispatchError) -> StopTriggerError {
StopTriggerError::HttpDispatch(err)
}
}
impl From<io::Error> for StopTriggerError {
fn from(err: io::Error) -> StopTriggerError {
StopTriggerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StopTriggerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StopTriggerError {
fn description(&self) -> &str {
match *self {
StopTriggerError::ConcurrentModification(ref cause) => cause,
StopTriggerError::EntityNotFound(ref cause) => cause,
StopTriggerError::InternalService(ref cause) => cause,
StopTriggerError::InvalidInput(ref cause) => cause,
StopTriggerError::OperationTimeout(ref cause) => cause,
StopTriggerError::Validation(ref cause) => cause,
StopTriggerError::Credentials(ref err) => err.description(),
StopTriggerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
StopTriggerError::ParseError(ref cause) => cause,
StopTriggerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateClassifierError {
EntityNotFound(String),
InvalidInput(String),
OperationTimeout(String),
VersionMismatch(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateClassifierError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateClassifierError {
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 {
"EntityNotFoundException" => {
return UpdateClassifierError::EntityNotFound(String::from(error_message))
}
"InvalidInputException" => {
return UpdateClassifierError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return UpdateClassifierError::OperationTimeout(String::from(error_message))
}
"VersionMismatchException" => {
return UpdateClassifierError::VersionMismatch(String::from(error_message))
}
"ValidationException" => {
return UpdateClassifierError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateClassifierError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateClassifierError {
fn from(err: serde_json::error::Error) -> UpdateClassifierError {
UpdateClassifierError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateClassifierError {
fn from(err: CredentialsError) -> UpdateClassifierError {
UpdateClassifierError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateClassifierError {
fn from(err: HttpDispatchError) -> UpdateClassifierError {
UpdateClassifierError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateClassifierError {
fn from(err: io::Error) -> UpdateClassifierError {
UpdateClassifierError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateClassifierError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateClassifierError {
fn description(&self) -> &str {
match *self {
UpdateClassifierError::EntityNotFound(ref cause) => cause,
UpdateClassifierError::InvalidInput(ref cause) => cause,
UpdateClassifierError::OperationTimeout(ref cause) => cause,
UpdateClassifierError::VersionMismatch(ref cause) => cause,
UpdateClassifierError::Validation(ref cause) => cause,
UpdateClassifierError::Credentials(ref err) => err.description(),
UpdateClassifierError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateClassifierError::ParseError(ref cause) => cause,
UpdateClassifierError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateConnectionError {
EntityNotFound(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateConnectionError {
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 {
"EntityNotFoundException" => {
return UpdateConnectionError::EntityNotFound(String::from(error_message))
}
"InvalidInputException" => {
return UpdateConnectionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return UpdateConnectionError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return UpdateConnectionError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateConnectionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateConnectionError {
fn from(err: serde_json::error::Error) -> UpdateConnectionError {
UpdateConnectionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateConnectionError {
fn from(err: CredentialsError) -> UpdateConnectionError {
UpdateConnectionError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateConnectionError {
fn from(err: HttpDispatchError) -> UpdateConnectionError {
UpdateConnectionError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateConnectionError {
fn from(err: io::Error) -> UpdateConnectionError {
UpdateConnectionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateConnectionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateConnectionError {
fn description(&self) -> &str {
match *self {
UpdateConnectionError::EntityNotFound(ref cause) => cause,
UpdateConnectionError::InvalidInput(ref cause) => cause,
UpdateConnectionError::OperationTimeout(ref cause) => cause,
UpdateConnectionError::Validation(ref cause) => cause,
UpdateConnectionError::Credentials(ref err) => err.description(),
UpdateConnectionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateConnectionError::ParseError(ref cause) => cause,
UpdateConnectionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateCrawlerError {
CrawlerRunning(String),
EntityNotFound(String),
InvalidInput(String),
OperationTimeout(String),
VersionMismatch(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateCrawlerError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateCrawlerError {
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 {
"CrawlerRunningException" => {
return UpdateCrawlerError::CrawlerRunning(String::from(error_message))
}
"EntityNotFoundException" => {
return UpdateCrawlerError::EntityNotFound(String::from(error_message))
}
"InvalidInputException" => {
return UpdateCrawlerError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return UpdateCrawlerError::OperationTimeout(String::from(error_message))
}
"VersionMismatchException" => {
return UpdateCrawlerError::VersionMismatch(String::from(error_message))
}
"ValidationException" => {
return UpdateCrawlerError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateCrawlerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateCrawlerError {
fn from(err: serde_json::error::Error) -> UpdateCrawlerError {
UpdateCrawlerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateCrawlerError {
fn from(err: CredentialsError) -> UpdateCrawlerError {
UpdateCrawlerError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateCrawlerError {
fn from(err: HttpDispatchError) -> UpdateCrawlerError {
UpdateCrawlerError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateCrawlerError {
fn from(err: io::Error) -> UpdateCrawlerError {
UpdateCrawlerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateCrawlerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateCrawlerError {
fn description(&self) -> &str {
match *self {
UpdateCrawlerError::CrawlerRunning(ref cause) => cause,
UpdateCrawlerError::EntityNotFound(ref cause) => cause,
UpdateCrawlerError::InvalidInput(ref cause) => cause,
UpdateCrawlerError::OperationTimeout(ref cause) => cause,
UpdateCrawlerError::VersionMismatch(ref cause) => cause,
UpdateCrawlerError::Validation(ref cause) => cause,
UpdateCrawlerError::Credentials(ref err) => err.description(),
UpdateCrawlerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateCrawlerError::ParseError(ref cause) => cause,
UpdateCrawlerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateCrawlerScheduleError {
EntityNotFound(String),
InvalidInput(String),
OperationTimeout(String),
SchedulerTransitioning(String),
VersionMismatch(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateCrawlerScheduleError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateCrawlerScheduleError {
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 {
"EntityNotFoundException" => {
return UpdateCrawlerScheduleError::EntityNotFound(String::from(error_message))
}
"InvalidInputException" => {
return UpdateCrawlerScheduleError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return UpdateCrawlerScheduleError::OperationTimeout(String::from(error_message))
}
"SchedulerTransitioningException" => {
return UpdateCrawlerScheduleError::SchedulerTransitioning(String::from(
error_message,
))
}
"VersionMismatchException" => {
return UpdateCrawlerScheduleError::VersionMismatch(String::from(error_message))
}
"ValidationException" => {
return UpdateCrawlerScheduleError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateCrawlerScheduleError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateCrawlerScheduleError {
fn from(err: serde_json::error::Error) -> UpdateCrawlerScheduleError {
UpdateCrawlerScheduleError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateCrawlerScheduleError {
fn from(err: CredentialsError) -> UpdateCrawlerScheduleError {
UpdateCrawlerScheduleError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateCrawlerScheduleError {
fn from(err: HttpDispatchError) -> UpdateCrawlerScheduleError {
UpdateCrawlerScheduleError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateCrawlerScheduleError {
fn from(err: io::Error) -> UpdateCrawlerScheduleError {
UpdateCrawlerScheduleError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateCrawlerScheduleError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateCrawlerScheduleError {
fn description(&self) -> &str {
match *self {
UpdateCrawlerScheduleError::EntityNotFound(ref cause) => cause,
UpdateCrawlerScheduleError::InvalidInput(ref cause) => cause,
UpdateCrawlerScheduleError::OperationTimeout(ref cause) => cause,
UpdateCrawlerScheduleError::SchedulerTransitioning(ref cause) => cause,
UpdateCrawlerScheduleError::VersionMismatch(ref cause) => cause,
UpdateCrawlerScheduleError::Validation(ref cause) => cause,
UpdateCrawlerScheduleError::Credentials(ref err) => err.description(),
UpdateCrawlerScheduleError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateCrawlerScheduleError::ParseError(ref cause) => cause,
UpdateCrawlerScheduleError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateDatabaseError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateDatabaseError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateDatabaseError {
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 {
"EntityNotFoundException" => {
return UpdateDatabaseError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return UpdateDatabaseError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return UpdateDatabaseError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return UpdateDatabaseError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return UpdateDatabaseError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateDatabaseError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateDatabaseError {
fn from(err: serde_json::error::Error) -> UpdateDatabaseError {
UpdateDatabaseError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateDatabaseError {
fn from(err: CredentialsError) -> UpdateDatabaseError {
UpdateDatabaseError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateDatabaseError {
fn from(err: HttpDispatchError) -> UpdateDatabaseError {
UpdateDatabaseError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateDatabaseError {
fn from(err: io::Error) -> UpdateDatabaseError {
UpdateDatabaseError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateDatabaseError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateDatabaseError {
fn description(&self) -> &str {
match *self {
UpdateDatabaseError::EntityNotFound(ref cause) => cause,
UpdateDatabaseError::InternalService(ref cause) => cause,
UpdateDatabaseError::InvalidInput(ref cause) => cause,
UpdateDatabaseError::OperationTimeout(ref cause) => cause,
UpdateDatabaseError::Validation(ref cause) => cause,
UpdateDatabaseError::Credentials(ref err) => err.description(),
UpdateDatabaseError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateDatabaseError::ParseError(ref cause) => cause,
UpdateDatabaseError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateDevEndpointError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateDevEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateDevEndpointError {
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 {
"EntityNotFoundException" => {
return UpdateDevEndpointError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return UpdateDevEndpointError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return UpdateDevEndpointError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return UpdateDevEndpointError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return UpdateDevEndpointError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateDevEndpointError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateDevEndpointError {
fn from(err: serde_json::error::Error) -> UpdateDevEndpointError {
UpdateDevEndpointError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateDevEndpointError {
fn from(err: CredentialsError) -> UpdateDevEndpointError {
UpdateDevEndpointError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateDevEndpointError {
fn from(err: HttpDispatchError) -> UpdateDevEndpointError {
UpdateDevEndpointError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateDevEndpointError {
fn from(err: io::Error) -> UpdateDevEndpointError {
UpdateDevEndpointError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateDevEndpointError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateDevEndpointError {
fn description(&self) -> &str {
match *self {
UpdateDevEndpointError::EntityNotFound(ref cause) => cause,
UpdateDevEndpointError::InternalService(ref cause) => cause,
UpdateDevEndpointError::InvalidInput(ref cause) => cause,
UpdateDevEndpointError::OperationTimeout(ref cause) => cause,
UpdateDevEndpointError::Validation(ref cause) => cause,
UpdateDevEndpointError::Credentials(ref err) => err.description(),
UpdateDevEndpointError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateDevEndpointError::ParseError(ref cause) => cause,
UpdateDevEndpointError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateJobError {
ConcurrentModification(String),
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateJobError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateJobError {
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 UpdateJobError::ConcurrentModification(String::from(error_message))
}
"EntityNotFoundException" => {
return UpdateJobError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return UpdateJobError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return UpdateJobError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return UpdateJobError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return UpdateJobError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateJobError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateJobError {
fn from(err: serde_json::error::Error) -> UpdateJobError {
UpdateJobError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateJobError {
fn from(err: CredentialsError) -> UpdateJobError {
UpdateJobError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateJobError {
fn from(err: HttpDispatchError) -> UpdateJobError {
UpdateJobError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateJobError {
fn from(err: io::Error) -> UpdateJobError {
UpdateJobError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateJobError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateJobError {
fn description(&self) -> &str {
match *self {
UpdateJobError::ConcurrentModification(ref cause) => cause,
UpdateJobError::EntityNotFound(ref cause) => cause,
UpdateJobError::InternalService(ref cause) => cause,
UpdateJobError::InvalidInput(ref cause) => cause,
UpdateJobError::OperationTimeout(ref cause) => cause,
UpdateJobError::Validation(ref cause) => cause,
UpdateJobError::Credentials(ref err) => err.description(),
UpdateJobError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateJobError::ParseError(ref cause) => cause,
UpdateJobError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdatePartitionError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdatePartitionError {
pub fn from_response(res: BufferedHttpResponse) -> UpdatePartitionError {
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 {
"EntityNotFoundException" => {
return UpdatePartitionError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return UpdatePartitionError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return UpdatePartitionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return UpdatePartitionError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return UpdatePartitionError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdatePartitionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdatePartitionError {
fn from(err: serde_json::error::Error) -> UpdatePartitionError {
UpdatePartitionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdatePartitionError {
fn from(err: CredentialsError) -> UpdatePartitionError {
UpdatePartitionError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdatePartitionError {
fn from(err: HttpDispatchError) -> UpdatePartitionError {
UpdatePartitionError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdatePartitionError {
fn from(err: io::Error) -> UpdatePartitionError {
UpdatePartitionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdatePartitionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdatePartitionError {
fn description(&self) -> &str {
match *self {
UpdatePartitionError::EntityNotFound(ref cause) => cause,
UpdatePartitionError::InternalService(ref cause) => cause,
UpdatePartitionError::InvalidInput(ref cause) => cause,
UpdatePartitionError::OperationTimeout(ref cause) => cause,
UpdatePartitionError::Validation(ref cause) => cause,
UpdatePartitionError::Credentials(ref err) => err.description(),
UpdatePartitionError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdatePartitionError::ParseError(ref cause) => cause,
UpdatePartitionError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateTableError {
ConcurrentModification(String),
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
ResourceNumberLimitExceeded(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateTableError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateTableError {
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 UpdateTableError::ConcurrentModification(String::from(error_message))
}
"EntityNotFoundException" => {
return UpdateTableError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return UpdateTableError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return UpdateTableError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return UpdateTableError::OperationTimeout(String::from(error_message))
}
"ResourceNumberLimitExceededException" => {
return UpdateTableError::ResourceNumberLimitExceeded(String::from(
error_message,
))
}
"ValidationException" => {
return UpdateTableError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateTableError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateTableError {
fn from(err: serde_json::error::Error) -> UpdateTableError {
UpdateTableError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateTableError {
fn from(err: CredentialsError) -> UpdateTableError {
UpdateTableError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateTableError {
fn from(err: HttpDispatchError) -> UpdateTableError {
UpdateTableError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateTableError {
fn from(err: io::Error) -> UpdateTableError {
UpdateTableError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateTableError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateTableError {
fn description(&self) -> &str {
match *self {
UpdateTableError::ConcurrentModification(ref cause) => cause,
UpdateTableError::EntityNotFound(ref cause) => cause,
UpdateTableError::InternalService(ref cause) => cause,
UpdateTableError::InvalidInput(ref cause) => cause,
UpdateTableError::OperationTimeout(ref cause) => cause,
UpdateTableError::ResourceNumberLimitExceeded(ref cause) => cause,
UpdateTableError::Validation(ref cause) => cause,
UpdateTableError::Credentials(ref err) => err.description(),
UpdateTableError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateTableError::ParseError(ref cause) => cause,
UpdateTableError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateTriggerError {
ConcurrentModification(String),
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateTriggerError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateTriggerError {
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 UpdateTriggerError::ConcurrentModification(String::from(error_message))
}
"EntityNotFoundException" => {
return UpdateTriggerError::EntityNotFound(String::from(error_message))
}
"InternalServiceException" => {
return UpdateTriggerError::InternalService(String::from(error_message))
}
"InvalidInputException" => {
return UpdateTriggerError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return UpdateTriggerError::OperationTimeout(String::from(error_message))
}
"ValidationException" => {
return UpdateTriggerError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateTriggerError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateTriggerError {
fn from(err: serde_json::error::Error) -> UpdateTriggerError {
UpdateTriggerError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateTriggerError {
fn from(err: CredentialsError) -> UpdateTriggerError {
UpdateTriggerError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateTriggerError {
fn from(err: HttpDispatchError) -> UpdateTriggerError {
UpdateTriggerError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateTriggerError {
fn from(err: io::Error) -> UpdateTriggerError {
UpdateTriggerError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateTriggerError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateTriggerError {
fn description(&self) -> &str {
match *self {
UpdateTriggerError::ConcurrentModification(ref cause) => cause,
UpdateTriggerError::EntityNotFound(ref cause) => cause,
UpdateTriggerError::InternalService(ref cause) => cause,
UpdateTriggerError::InvalidInput(ref cause) => cause,
UpdateTriggerError::OperationTimeout(ref cause) => cause,
UpdateTriggerError::Validation(ref cause) => cause,
UpdateTriggerError::Credentials(ref err) => err.description(),
UpdateTriggerError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateTriggerError::ParseError(ref cause) => cause,
UpdateTriggerError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateUserDefinedFunctionError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateUserDefinedFunctionError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateUserDefinedFunctionError {
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 {
"EntityNotFoundException" => {
return UpdateUserDefinedFunctionError::EntityNotFound(String::from(
error_message,
))
}
"InternalServiceException" => {
return UpdateUserDefinedFunctionError::InternalService(String::from(
error_message,
))
}
"InvalidInputException" => {
return UpdateUserDefinedFunctionError::InvalidInput(String::from(error_message))
}
"OperationTimeoutException" => {
return UpdateUserDefinedFunctionError::OperationTimeout(String::from(
error_message,
))
}
"ValidationException" => {
return UpdateUserDefinedFunctionError::Validation(error_message.to_string())
}
_ => {}
}
}
return UpdateUserDefinedFunctionError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateUserDefinedFunctionError {
fn from(err: serde_json::error::Error) -> UpdateUserDefinedFunctionError {
UpdateUserDefinedFunctionError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateUserDefinedFunctionError {
fn from(err: CredentialsError) -> UpdateUserDefinedFunctionError {
UpdateUserDefinedFunctionError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateUserDefinedFunctionError {
fn from(err: HttpDispatchError) -> UpdateUserDefinedFunctionError {
UpdateUserDefinedFunctionError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateUserDefinedFunctionError {
fn from(err: io::Error) -> UpdateUserDefinedFunctionError {
UpdateUserDefinedFunctionError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateUserDefinedFunctionError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateUserDefinedFunctionError {
fn description(&self) -> &str {
match *self {
UpdateUserDefinedFunctionError::EntityNotFound(ref cause) => cause,
UpdateUserDefinedFunctionError::InternalService(ref cause) => cause,
UpdateUserDefinedFunctionError::InvalidInput(ref cause) => cause,
UpdateUserDefinedFunctionError::OperationTimeout(ref cause) => cause,
UpdateUserDefinedFunctionError::Validation(ref cause) => cause,
UpdateUserDefinedFunctionError::Credentials(ref err) => err.description(),
UpdateUserDefinedFunctionError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateUserDefinedFunctionError::ParseError(ref cause) => cause,
UpdateUserDefinedFunctionError::Unknown(_) => "unknown error",
}
}
}
pub trait Glue {
fn batch_create_partition(
&self,
input: BatchCreatePartitionRequest,
) -> RusotoFuture<BatchCreatePartitionResponse, BatchCreatePartitionError>;
fn batch_delete_connection(
&self,
input: BatchDeleteConnectionRequest,
) -> RusotoFuture<BatchDeleteConnectionResponse, BatchDeleteConnectionError>;
fn batch_delete_partition(
&self,
input: BatchDeletePartitionRequest,
) -> RusotoFuture<BatchDeletePartitionResponse, BatchDeletePartitionError>;
fn batch_delete_table(
&self,
input: BatchDeleteTableRequest,
) -> RusotoFuture<BatchDeleteTableResponse, BatchDeleteTableError>;
fn batch_delete_table_version(
&self,
input: BatchDeleteTableVersionRequest,
) -> RusotoFuture<BatchDeleteTableVersionResponse, BatchDeleteTableVersionError>;
fn batch_get_partition(
&self,
input: BatchGetPartitionRequest,
) -> RusotoFuture<BatchGetPartitionResponse, BatchGetPartitionError>;
fn batch_stop_job_run(
&self,
input: BatchStopJobRunRequest,
) -> RusotoFuture<BatchStopJobRunResponse, GlueBatchStopJobRunError>;
fn create_classifier(
&self,
input: CreateClassifierRequest,
) -> RusotoFuture<CreateClassifierResponse, CreateClassifierError>;
fn create_connection(
&self,
input: CreateConnectionRequest,
) -> RusotoFuture<CreateConnectionResponse, CreateConnectionError>;
fn create_crawler(
&self,
input: CreateCrawlerRequest,
) -> RusotoFuture<CreateCrawlerResponse, CreateCrawlerError>;
fn create_database(
&self,
input: CreateDatabaseRequest,
) -> RusotoFuture<CreateDatabaseResponse, CreateDatabaseError>;
fn create_dev_endpoint(
&self,
input: CreateDevEndpointRequest,
) -> RusotoFuture<CreateDevEndpointResponse, CreateDevEndpointError>;
fn create_job(
&self,
input: CreateJobRequest,
) -> RusotoFuture<CreateJobResponse, CreateJobError>;
fn create_partition(
&self,
input: CreatePartitionRequest,
) -> RusotoFuture<CreatePartitionResponse, CreatePartitionError>;
fn create_script(
&self,
input: CreateScriptRequest,
) -> RusotoFuture<CreateScriptResponse, CreateScriptError>;
fn create_table(
&self,
input: CreateTableRequest,
) -> RusotoFuture<CreateTableResponse, CreateTableError>;
fn create_trigger(
&self,
input: CreateTriggerRequest,
) -> RusotoFuture<CreateTriggerResponse, CreateTriggerError>;
fn create_user_defined_function(
&self,
input: CreateUserDefinedFunctionRequest,
) -> RusotoFuture<CreateUserDefinedFunctionResponse, CreateUserDefinedFunctionError>;
fn delete_classifier(
&self,
input: DeleteClassifierRequest,
) -> RusotoFuture<DeleteClassifierResponse, DeleteClassifierError>;
fn delete_connection(
&self,
input: DeleteConnectionRequest,
) -> RusotoFuture<DeleteConnectionResponse, DeleteConnectionError>;
fn delete_crawler(
&self,
input: DeleteCrawlerRequest,
) -> RusotoFuture<DeleteCrawlerResponse, DeleteCrawlerError>;
fn delete_database(
&self,
input: DeleteDatabaseRequest,
) -> RusotoFuture<DeleteDatabaseResponse, DeleteDatabaseError>;
fn delete_dev_endpoint(
&self,
input: DeleteDevEndpointRequest,
) -> RusotoFuture<DeleteDevEndpointResponse, DeleteDevEndpointError>;
fn delete_job(
&self,
input: DeleteJobRequest,
) -> RusotoFuture<DeleteJobResponse, DeleteJobError>;
fn delete_partition(
&self,
input: DeletePartitionRequest,
) -> RusotoFuture<DeletePartitionResponse, DeletePartitionError>;
fn delete_table(
&self,
input: DeleteTableRequest,
) -> RusotoFuture<DeleteTableResponse, DeleteTableError>;
fn delete_table_version(
&self,
input: DeleteTableVersionRequest,
) -> RusotoFuture<DeleteTableVersionResponse, DeleteTableVersionError>;
fn delete_trigger(
&self,
input: DeleteTriggerRequest,
) -> RusotoFuture<DeleteTriggerResponse, DeleteTriggerError>;
fn delete_user_defined_function(
&self,
input: DeleteUserDefinedFunctionRequest,
) -> RusotoFuture<DeleteUserDefinedFunctionResponse, DeleteUserDefinedFunctionError>;
fn get_catalog_import_status(
&self,
input: GetCatalogImportStatusRequest,
) -> RusotoFuture<GetCatalogImportStatusResponse, GetCatalogImportStatusError>;
fn get_classifier(
&self,
input: GetClassifierRequest,
) -> RusotoFuture<GetClassifierResponse, GetClassifierError>;
fn get_classifiers(
&self,
input: GetClassifiersRequest,
) -> RusotoFuture<GetClassifiersResponse, GetClassifiersError>;
fn get_connection(
&self,
input: GetConnectionRequest,
) -> RusotoFuture<GetConnectionResponse, GetConnectionError>;
fn get_connections(
&self,
input: GetConnectionsRequest,
) -> RusotoFuture<GetConnectionsResponse, GetConnectionsError>;
fn get_crawler(
&self,
input: GetCrawlerRequest,
) -> RusotoFuture<GetCrawlerResponse, GetCrawlerError>;
fn get_crawler_metrics(
&self,
input: GetCrawlerMetricsRequest,
) -> RusotoFuture<GetCrawlerMetricsResponse, GetCrawlerMetricsError>;
fn get_crawlers(
&self,
input: GetCrawlersRequest,
) -> RusotoFuture<GetCrawlersResponse, GetCrawlersError>;
fn get_database(
&self,
input: GetDatabaseRequest,
) -> RusotoFuture<GetDatabaseResponse, GetDatabaseError>;
fn get_databases(
&self,
input: GetDatabasesRequest,
) -> RusotoFuture<GetDatabasesResponse, GetDatabasesError>;
fn get_dataflow_graph(
&self,
input: GetDataflowGraphRequest,
) -> RusotoFuture<GetDataflowGraphResponse, GetDataflowGraphError>;
fn get_dev_endpoint(
&self,
input: GetDevEndpointRequest,
) -> RusotoFuture<GetDevEndpointResponse, GetDevEndpointError>;
fn get_dev_endpoints(
&self,
input: GetDevEndpointsRequest,
) -> RusotoFuture<GetDevEndpointsResponse, GetDevEndpointsError>;
fn get_job(&self, input: GetJobRequest) -> RusotoFuture<GetJobResponse, GetJobError>;
fn get_job_run(
&self,
input: GetJobRunRequest,
) -> RusotoFuture<GetJobRunResponse, GetJobRunError>;
fn get_job_runs(
&self,
input: GetJobRunsRequest,
) -> RusotoFuture<GetJobRunsResponse, GetJobRunsError>;
fn get_jobs(&self, input: GetJobsRequest) -> RusotoFuture<GetJobsResponse, GetJobsError>;
fn get_mapping(
&self,
input: GetMappingRequest,
) -> RusotoFuture<GetMappingResponse, GetMappingError>;
fn get_partition(
&self,
input: GetPartitionRequest,
) -> RusotoFuture<GetPartitionResponse, GetPartitionError>;
fn get_partitions(
&self,
input: GetPartitionsRequest,
) -> RusotoFuture<GetPartitionsResponse, GetPartitionsError>;
fn get_plan(&self, input: GetPlanRequest) -> RusotoFuture<GetPlanResponse, GetPlanError>;
fn get_table(&self, input: GetTableRequest) -> RusotoFuture<GetTableResponse, GetTableError>;
fn get_table_version(
&self,
input: GetTableVersionRequest,
) -> RusotoFuture<GetTableVersionResponse, GetTableVersionError>;
fn get_table_versions(
&self,
input: GetTableVersionsRequest,
) -> RusotoFuture<GetTableVersionsResponse, GetTableVersionsError>;
fn get_tables(
&self,
input: GetTablesRequest,
) -> RusotoFuture<GetTablesResponse, GetTablesError>;
fn get_trigger(
&self,
input: GetTriggerRequest,
) -> RusotoFuture<GetTriggerResponse, GetTriggerError>;
fn get_triggers(
&self,
input: GetTriggersRequest,
) -> RusotoFuture<GetTriggersResponse, GetTriggersError>;
fn get_user_defined_function(
&self,
input: GetUserDefinedFunctionRequest,
) -> RusotoFuture<GetUserDefinedFunctionResponse, GetUserDefinedFunctionError>;
fn get_user_defined_functions(
&self,
input: GetUserDefinedFunctionsRequest,
) -> RusotoFuture<GetUserDefinedFunctionsResponse, GetUserDefinedFunctionsError>;
fn import_catalog_to_glue(
&self,
input: ImportCatalogToGlueRequest,
) -> RusotoFuture<ImportCatalogToGlueResponse, ImportCatalogToGlueError>;
fn reset_job_bookmark(
&self,
input: ResetJobBookmarkRequest,
) -> RusotoFuture<ResetJobBookmarkResponse, ResetJobBookmarkError>;
fn start_crawler(
&self,
input: StartCrawlerRequest,
) -> RusotoFuture<StartCrawlerResponse, StartCrawlerError>;
fn start_crawler_schedule(
&self,
input: StartCrawlerScheduleRequest,
) -> RusotoFuture<StartCrawlerScheduleResponse, StartCrawlerScheduleError>;
fn start_job_run(
&self,
input: StartJobRunRequest,
) -> RusotoFuture<StartJobRunResponse, StartJobRunError>;
fn start_trigger(
&self,
input: StartTriggerRequest,
) -> RusotoFuture<StartTriggerResponse, StartTriggerError>;
fn stop_crawler(
&self,
input: StopCrawlerRequest,
) -> RusotoFuture<StopCrawlerResponse, StopCrawlerError>;
fn stop_crawler_schedule(
&self,
input: StopCrawlerScheduleRequest,
) -> RusotoFuture<StopCrawlerScheduleResponse, StopCrawlerScheduleError>;
fn stop_trigger(
&self,
input: StopTriggerRequest,
) -> RusotoFuture<StopTriggerResponse, StopTriggerError>;
fn update_classifier(
&self,
input: UpdateClassifierRequest,
) -> RusotoFuture<UpdateClassifierResponse, UpdateClassifierError>;
fn update_connection(
&self,
input: UpdateConnectionRequest,
) -> RusotoFuture<UpdateConnectionResponse, UpdateConnectionError>;
fn update_crawler(
&self,
input: UpdateCrawlerRequest,
) -> RusotoFuture<UpdateCrawlerResponse, UpdateCrawlerError>;
fn update_crawler_schedule(
&self,
input: UpdateCrawlerScheduleRequest,
) -> RusotoFuture<UpdateCrawlerScheduleResponse, UpdateCrawlerScheduleError>;
fn update_database(
&self,
input: UpdateDatabaseRequest,
) -> RusotoFuture<UpdateDatabaseResponse, UpdateDatabaseError>;
fn update_dev_endpoint(
&self,
input: UpdateDevEndpointRequest,
) -> RusotoFuture<UpdateDevEndpointResponse, UpdateDevEndpointError>;
fn update_job(
&self,
input: UpdateJobRequest,
) -> RusotoFuture<UpdateJobResponse, UpdateJobError>;
fn update_partition(
&self,
input: UpdatePartitionRequest,
) -> RusotoFuture<UpdatePartitionResponse, UpdatePartitionError>;
fn update_table(
&self,
input: UpdateTableRequest,
) -> RusotoFuture<UpdateTableResponse, UpdateTableError>;
fn update_trigger(
&self,
input: UpdateTriggerRequest,
) -> RusotoFuture<UpdateTriggerResponse, UpdateTriggerError>;
fn update_user_defined_function(
&self,
input: UpdateUserDefinedFunctionRequest,
) -> RusotoFuture<UpdateUserDefinedFunctionResponse, UpdateUserDefinedFunctionError>;
}
pub struct GlueClient {
client: Client,
region: region::Region,
}
impl GlueClient {
pub fn new(region: region::Region) -> GlueClient {
GlueClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> GlueClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
GlueClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl Glue for GlueClient {
fn batch_create_partition(
&self,
input: BatchCreatePartitionRequest,
) -> RusotoFuture<BatchCreatePartitionResponse, BatchCreatePartitionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.BatchCreatePartition");
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::<BatchCreatePartitionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(BatchCreatePartitionError::from_response(response))
}),
)
}
})
}
fn batch_delete_connection(
&self,
input: BatchDeleteConnectionRequest,
) -> RusotoFuture<BatchDeleteConnectionResponse, BatchDeleteConnectionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.BatchDeleteConnection");
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::<BatchDeleteConnectionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(BatchDeleteConnectionError::from_response(response))
}),
)
}
})
}
fn batch_delete_partition(
&self,
input: BatchDeletePartitionRequest,
) -> RusotoFuture<BatchDeletePartitionResponse, BatchDeletePartitionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.BatchDeletePartition");
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::<BatchDeletePartitionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(BatchDeletePartitionError::from_response(response))
}),
)
}
})
}
fn batch_delete_table(
&self,
input: BatchDeleteTableRequest,
) -> RusotoFuture<BatchDeleteTableResponse, BatchDeleteTableError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.BatchDeleteTable");
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::<BatchDeleteTableResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(BatchDeleteTableError::from_response(response))),
)
}
})
}
fn batch_delete_table_version(
&self,
input: BatchDeleteTableVersionRequest,
) -> RusotoFuture<BatchDeleteTableVersionResponse, BatchDeleteTableVersionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.BatchDeleteTableVersion");
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::<BatchDeleteTableVersionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(BatchDeleteTableVersionError::from_response(response))
}))
}
})
}
fn batch_get_partition(
&self,
input: BatchGetPartitionRequest,
) -> RusotoFuture<BatchGetPartitionResponse, BatchGetPartitionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.BatchGetPartition");
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::<BatchGetPartitionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(BatchGetPartitionError::from_response(response))),
)
}
})
}
fn batch_stop_job_run(
&self,
input: BatchStopJobRunRequest,
) -> RusotoFuture<BatchStopJobRunResponse, GlueBatchStopJobRunError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.BatchStopJobRun");
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::<BatchStopJobRunResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GlueBatchStopJobRunError::from_response(response))
}),
)
}
})
}
fn create_classifier(
&self,
input: CreateClassifierRequest,
) -> RusotoFuture<CreateClassifierResponse, CreateClassifierError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.CreateClassifier");
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::<CreateClassifierResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateClassifierError::from_response(response))),
)
}
})
}
fn create_connection(
&self,
input: CreateConnectionRequest,
) -> RusotoFuture<CreateConnectionResponse, CreateConnectionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.CreateConnection");
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::<CreateConnectionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateConnectionError::from_response(response))),
)
}
})
}
fn create_crawler(
&self,
input: CreateCrawlerRequest,
) -> RusotoFuture<CreateCrawlerResponse, CreateCrawlerError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.CreateCrawler");
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::<CreateCrawlerResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateCrawlerError::from_response(response))),
)
}
})
}
fn create_database(
&self,
input: CreateDatabaseRequest,
) -> RusotoFuture<CreateDatabaseResponse, CreateDatabaseError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.CreateDatabase");
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::<CreateDatabaseResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateDatabaseError::from_response(response))),
)
}
})
}
fn create_dev_endpoint(
&self,
input: CreateDevEndpointRequest,
) -> RusotoFuture<CreateDevEndpointResponse, CreateDevEndpointError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.CreateDevEndpoint");
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::<CreateDevEndpointResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateDevEndpointError::from_response(response))),
)
}
})
}
fn create_job(
&self,
input: CreateJobRequest,
) -> RusotoFuture<CreateJobResponse, CreateJobError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.CreateJob");
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::<CreateJobResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateJobError::from_response(response))),
)
}
})
}
fn create_partition(
&self,
input: CreatePartitionRequest,
) -> RusotoFuture<CreatePartitionResponse, CreatePartitionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.CreatePartition");
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::<CreatePartitionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreatePartitionError::from_response(response))),
)
}
})
}
fn create_script(
&self,
input: CreateScriptRequest,
) -> RusotoFuture<CreateScriptResponse, CreateScriptError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.CreateScript");
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::<CreateScriptResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateScriptError::from_response(response))),
)
}
})
}
fn create_table(
&self,
input: CreateTableRequest,
) -> RusotoFuture<CreateTableResponse, CreateTableError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.CreateTable");
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::<CreateTableResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateTableError::from_response(response))),
)
}
})
}
fn create_trigger(
&self,
input: CreateTriggerRequest,
) -> RusotoFuture<CreateTriggerResponse, CreateTriggerError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.CreateTrigger");
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::<CreateTriggerResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateTriggerError::from_response(response))),
)
}
})
}
fn create_user_defined_function(
&self,
input: CreateUserDefinedFunctionRequest,
) -> RusotoFuture<CreateUserDefinedFunctionResponse, CreateUserDefinedFunctionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.CreateUserDefinedFunction");
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::<CreateUserDefinedFunctionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateUserDefinedFunctionError::from_response(response))
}))
}
})
}
fn delete_classifier(
&self,
input: DeleteClassifierRequest,
) -> RusotoFuture<DeleteClassifierResponse, DeleteClassifierError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.DeleteClassifier");
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::<DeleteClassifierResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteClassifierError::from_response(response))),
)
}
})
}
fn delete_connection(
&self,
input: DeleteConnectionRequest,
) -> RusotoFuture<DeleteConnectionResponse, DeleteConnectionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.DeleteConnection");
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::<DeleteConnectionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteConnectionError::from_response(response))),
)
}
})
}
fn delete_crawler(
&self,
input: DeleteCrawlerRequest,
) -> RusotoFuture<DeleteCrawlerResponse, DeleteCrawlerError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.DeleteCrawler");
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::<DeleteCrawlerResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteCrawlerError::from_response(response))),
)
}
})
}
fn delete_database(
&self,
input: DeleteDatabaseRequest,
) -> RusotoFuture<DeleteDatabaseResponse, DeleteDatabaseError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.DeleteDatabase");
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::<DeleteDatabaseResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteDatabaseError::from_response(response))),
)
}
})
}
fn delete_dev_endpoint(
&self,
input: DeleteDevEndpointRequest,
) -> RusotoFuture<DeleteDevEndpointResponse, DeleteDevEndpointError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.DeleteDevEndpoint");
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::<DeleteDevEndpointResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteDevEndpointError::from_response(response))),
)
}
})
}
fn delete_job(
&self,
input: DeleteJobRequest,
) -> RusotoFuture<DeleteJobResponse, DeleteJobError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.DeleteJob");
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::<DeleteJobResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteJobError::from_response(response))),
)
}
})
}
fn delete_partition(
&self,
input: DeletePartitionRequest,
) -> RusotoFuture<DeletePartitionResponse, DeletePartitionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.DeletePartition");
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::<DeletePartitionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeletePartitionError::from_response(response))),
)
}
})
}
fn delete_table(
&self,
input: DeleteTableRequest,
) -> RusotoFuture<DeleteTableResponse, DeleteTableError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.DeleteTable");
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::<DeleteTableResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteTableError::from_response(response))),
)
}
})
}
fn delete_table_version(
&self,
input: DeleteTableVersionRequest,
) -> RusotoFuture<DeleteTableVersionResponse, DeleteTableVersionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.DeleteTableVersion");
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::<DeleteTableVersionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteTableVersionError::from_response(response))),
)
}
})
}
fn delete_trigger(
&self,
input: DeleteTriggerRequest,
) -> RusotoFuture<DeleteTriggerResponse, DeleteTriggerError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.DeleteTrigger");
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::<DeleteTriggerResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteTriggerError::from_response(response))),
)
}
})
}
fn delete_user_defined_function(
&self,
input: DeleteUserDefinedFunctionRequest,
) -> RusotoFuture<DeleteUserDefinedFunctionResponse, DeleteUserDefinedFunctionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.DeleteUserDefinedFunction");
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::<DeleteUserDefinedFunctionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteUserDefinedFunctionError::from_response(response))
}))
}
})
}
fn get_catalog_import_status(
&self,
input: GetCatalogImportStatusRequest,
) -> RusotoFuture<GetCatalogImportStatusResponse, GetCatalogImportStatusError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetCatalogImportStatus");
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::<GetCatalogImportStatusResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetCatalogImportStatusError::from_response(response))
}),
)
}
})
}
fn get_classifier(
&self,
input: GetClassifierRequest,
) -> RusotoFuture<GetClassifierResponse, GetClassifierError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetClassifier");
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::<GetClassifierResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetClassifierError::from_response(response))),
)
}
})
}
fn get_classifiers(
&self,
input: GetClassifiersRequest,
) -> RusotoFuture<GetClassifiersResponse, GetClassifiersError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetClassifiers");
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::<GetClassifiersResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetClassifiersError::from_response(response))),
)
}
})
}
fn get_connection(
&self,
input: GetConnectionRequest,
) -> RusotoFuture<GetConnectionResponse, GetConnectionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetConnection");
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::<GetConnectionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetConnectionError::from_response(response))),
)
}
})
}
fn get_connections(
&self,
input: GetConnectionsRequest,
) -> RusotoFuture<GetConnectionsResponse, GetConnectionsError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetConnections");
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::<GetConnectionsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetConnectionsError::from_response(response))),
)
}
})
}
fn get_crawler(
&self,
input: GetCrawlerRequest,
) -> RusotoFuture<GetCrawlerResponse, GetCrawlerError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetCrawler");
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::<GetCrawlerResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetCrawlerError::from_response(response))),
)
}
})
}
fn get_crawler_metrics(
&self,
input: GetCrawlerMetricsRequest,
) -> RusotoFuture<GetCrawlerMetricsResponse, GetCrawlerMetricsError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetCrawlerMetrics");
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::<GetCrawlerMetricsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetCrawlerMetricsError::from_response(response))),
)
}
})
}
fn get_crawlers(
&self,
input: GetCrawlersRequest,
) -> RusotoFuture<GetCrawlersResponse, GetCrawlersError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetCrawlers");
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::<GetCrawlersResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetCrawlersError::from_response(response))),
)
}
})
}
fn get_database(
&self,
input: GetDatabaseRequest,
) -> RusotoFuture<GetDatabaseResponse, GetDatabaseError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetDatabase");
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::<GetDatabaseResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetDatabaseError::from_response(response))),
)
}
})
}
fn get_databases(
&self,
input: GetDatabasesRequest,
) -> RusotoFuture<GetDatabasesResponse, GetDatabasesError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetDatabases");
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::<GetDatabasesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetDatabasesError::from_response(response))),
)
}
})
}
fn get_dataflow_graph(
&self,
input: GetDataflowGraphRequest,
) -> RusotoFuture<GetDataflowGraphResponse, GetDataflowGraphError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetDataflowGraph");
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::<GetDataflowGraphResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetDataflowGraphError::from_response(response))),
)
}
})
}
fn get_dev_endpoint(
&self,
input: GetDevEndpointRequest,
) -> RusotoFuture<GetDevEndpointResponse, GetDevEndpointError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetDevEndpoint");
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::<GetDevEndpointResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetDevEndpointError::from_response(response))),
)
}
})
}
fn get_dev_endpoints(
&self,
input: GetDevEndpointsRequest,
) -> RusotoFuture<GetDevEndpointsResponse, GetDevEndpointsError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetDevEndpoints");
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::<GetDevEndpointsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetDevEndpointsError::from_response(response))),
)
}
})
}
fn get_job(&self, input: GetJobRequest) -> RusotoFuture<GetJobResponse, GetJobError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetJob");
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::<GetJobResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetJobError::from_response(response))),
)
}
})
}
fn get_job_run(
&self,
input: GetJobRunRequest,
) -> RusotoFuture<GetJobRunResponse, GetJobRunError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetJobRun");
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::<GetJobRunResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetJobRunError::from_response(response))),
)
}
})
}
fn get_job_runs(
&self,
input: GetJobRunsRequest,
) -> RusotoFuture<GetJobRunsResponse, GetJobRunsError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetJobRuns");
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::<GetJobRunsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetJobRunsError::from_response(response))),
)
}
})
}
fn get_jobs(&self, input: GetJobsRequest) -> RusotoFuture<GetJobsResponse, GetJobsError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetJobs");
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::<GetJobsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetJobsError::from_response(response))),
)
}
})
}
fn get_mapping(
&self,
input: GetMappingRequest,
) -> RusotoFuture<GetMappingResponse, GetMappingError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetMapping");
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::<GetMappingResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetMappingError::from_response(response))),
)
}
})
}
fn get_partition(
&self,
input: GetPartitionRequest,
) -> RusotoFuture<GetPartitionResponse, GetPartitionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetPartition");
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::<GetPartitionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetPartitionError::from_response(response))),
)
}
})
}
fn get_partitions(
&self,
input: GetPartitionsRequest,
) -> RusotoFuture<GetPartitionsResponse, GetPartitionsError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetPartitions");
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::<GetPartitionsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetPartitionsError::from_response(response))),
)
}
})
}
fn get_plan(&self, input: GetPlanRequest) -> RusotoFuture<GetPlanResponse, GetPlanError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetPlan");
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::<GetPlanResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetPlanError::from_response(response))),
)
}
})
}
fn get_table(&self, input: GetTableRequest) -> RusotoFuture<GetTableResponse, GetTableError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetTable");
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::<GetTableResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetTableError::from_response(response))),
)
}
})
}
fn get_table_version(
&self,
input: GetTableVersionRequest,
) -> RusotoFuture<GetTableVersionResponse, GetTableVersionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetTableVersion");
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::<GetTableVersionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetTableVersionError::from_response(response))),
)
}
})
}
fn get_table_versions(
&self,
input: GetTableVersionsRequest,
) -> RusotoFuture<GetTableVersionsResponse, GetTableVersionsError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetTableVersions");
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::<GetTableVersionsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetTableVersionsError::from_response(response))),
)
}
})
}
fn get_tables(
&self,
input: GetTablesRequest,
) -> RusotoFuture<GetTablesResponse, GetTablesError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetTables");
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::<GetTablesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetTablesError::from_response(response))),
)
}
})
}
fn get_trigger(
&self,
input: GetTriggerRequest,
) -> RusotoFuture<GetTriggerResponse, GetTriggerError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetTrigger");
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::<GetTriggerResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetTriggerError::from_response(response))),
)
}
})
}
fn get_triggers(
&self,
input: GetTriggersRequest,
) -> RusotoFuture<GetTriggersResponse, GetTriggersError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetTriggers");
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::<GetTriggersResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(GetTriggersError::from_response(response))),
)
}
})
}
fn get_user_defined_function(
&self,
input: GetUserDefinedFunctionRequest,
) -> RusotoFuture<GetUserDefinedFunctionResponse, GetUserDefinedFunctionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetUserDefinedFunction");
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::<GetUserDefinedFunctionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetUserDefinedFunctionError::from_response(response))
}),
)
}
})
}
fn get_user_defined_functions(
&self,
input: GetUserDefinedFunctionsRequest,
) -> RusotoFuture<GetUserDefinedFunctionsResponse, GetUserDefinedFunctionsError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.GetUserDefinedFunctions");
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::<GetUserDefinedFunctionsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(GetUserDefinedFunctionsError::from_response(response))
}))
}
})
}
fn import_catalog_to_glue(
&self,
input: ImportCatalogToGlueRequest,
) -> RusotoFuture<ImportCatalogToGlueResponse, ImportCatalogToGlueError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.ImportCatalogToGlue");
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::<ImportCatalogToGlueResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ImportCatalogToGlueError::from_response(response))
}),
)
}
})
}
fn reset_job_bookmark(
&self,
input: ResetJobBookmarkRequest,
) -> RusotoFuture<ResetJobBookmarkResponse, ResetJobBookmarkError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.ResetJobBookmark");
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::<ResetJobBookmarkResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ResetJobBookmarkError::from_response(response))),
)
}
})
}
fn start_crawler(
&self,
input: StartCrawlerRequest,
) -> RusotoFuture<StartCrawlerResponse, StartCrawlerError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.StartCrawler");
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::<StartCrawlerResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StartCrawlerError::from_response(response))),
)
}
})
}
fn start_crawler_schedule(
&self,
input: StartCrawlerScheduleRequest,
) -> RusotoFuture<StartCrawlerScheduleResponse, StartCrawlerScheduleError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.StartCrawlerSchedule");
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::<StartCrawlerScheduleResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(StartCrawlerScheduleError::from_response(response))
}),
)
}
})
}
fn start_job_run(
&self,
input: StartJobRunRequest,
) -> RusotoFuture<StartJobRunResponse, StartJobRunError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.StartJobRun");
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::<StartJobRunResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StartJobRunError::from_response(response))),
)
}
})
}
fn start_trigger(
&self,
input: StartTriggerRequest,
) -> RusotoFuture<StartTriggerResponse, StartTriggerError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.StartTrigger");
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::<StartTriggerResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StartTriggerError::from_response(response))),
)
}
})
}
fn stop_crawler(
&self,
input: StopCrawlerRequest,
) -> RusotoFuture<StopCrawlerResponse, StopCrawlerError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.StopCrawler");
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::<StopCrawlerResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StopCrawlerError::from_response(response))),
)
}
})
}
fn stop_crawler_schedule(
&self,
input: StopCrawlerScheduleRequest,
) -> RusotoFuture<StopCrawlerScheduleResponse, StopCrawlerScheduleError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.StopCrawlerSchedule");
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::<StopCrawlerScheduleResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(StopCrawlerScheduleError::from_response(response))
}),
)
}
})
}
fn stop_trigger(
&self,
input: StopTriggerRequest,
) -> RusotoFuture<StopTriggerResponse, StopTriggerError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.StopTrigger");
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::<StopTriggerResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StopTriggerError::from_response(response))),
)
}
})
}
fn update_classifier(
&self,
input: UpdateClassifierRequest,
) -> RusotoFuture<UpdateClassifierResponse, UpdateClassifierError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.UpdateClassifier");
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::<UpdateClassifierResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateClassifierError::from_response(response))),
)
}
})
}
fn update_connection(
&self,
input: UpdateConnectionRequest,
) -> RusotoFuture<UpdateConnectionResponse, UpdateConnectionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.UpdateConnection");
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::<UpdateConnectionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateConnectionError::from_response(response))),
)
}
})
}
fn update_crawler(
&self,
input: UpdateCrawlerRequest,
) -> RusotoFuture<UpdateCrawlerResponse, UpdateCrawlerError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.UpdateCrawler");
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::<UpdateCrawlerResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateCrawlerError::from_response(response))),
)
}
})
}
fn update_crawler_schedule(
&self,
input: UpdateCrawlerScheduleRequest,
) -> RusotoFuture<UpdateCrawlerScheduleResponse, UpdateCrawlerScheduleError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.UpdateCrawlerSchedule");
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::<UpdateCrawlerScheduleResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(UpdateCrawlerScheduleError::from_response(response))
}),
)
}
})
}
fn update_database(
&self,
input: UpdateDatabaseRequest,
) -> RusotoFuture<UpdateDatabaseResponse, UpdateDatabaseError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.UpdateDatabase");
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::<UpdateDatabaseResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateDatabaseError::from_response(response))),
)
}
})
}
fn update_dev_endpoint(
&self,
input: UpdateDevEndpointRequest,
) -> RusotoFuture<UpdateDevEndpointResponse, UpdateDevEndpointError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.UpdateDevEndpoint");
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::<UpdateDevEndpointResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateDevEndpointError::from_response(response))),
)
}
})
}
fn update_job(
&self,
input: UpdateJobRequest,
) -> RusotoFuture<UpdateJobResponse, UpdateJobError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.UpdateJob");
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::<UpdateJobResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateJobError::from_response(response))),
)
}
})
}
fn update_partition(
&self,
input: UpdatePartitionRequest,
) -> RusotoFuture<UpdatePartitionResponse, UpdatePartitionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.UpdatePartition");
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::<UpdatePartitionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdatePartitionError::from_response(response))),
)
}
})
}
fn update_table(
&self,
input: UpdateTableRequest,
) -> RusotoFuture<UpdateTableResponse, UpdateTableError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.UpdateTable");
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::<UpdateTableResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateTableError::from_response(response))),
)
}
})
}
fn update_trigger(
&self,
input: UpdateTriggerRequest,
) -> RusotoFuture<UpdateTriggerResponse, UpdateTriggerError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.UpdateTrigger");
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::<UpdateTriggerResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateTriggerError::from_response(response))),
)
}
})
}
fn update_user_defined_function(
&self,
input: UpdateUserDefinedFunctionRequest,
) -> RusotoFuture<UpdateUserDefinedFunctionResponse, UpdateUserDefinedFunctionError> {
let mut request = SignedRequest::new("POST", "glue", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "AWSGlue.UpdateUserDefinedFunction");
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::<UpdateUserDefinedFunctionResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdateUserDefinedFunctionError::from_response(response))
}))
}
})
}
}
#[cfg(test)]
mod protocol_tests {}