use std::error::Error;
use std::fmt;
use std::io;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoFuture};
use rusoto_core::credential::{CredentialsError, ProvideAwsCredentials};
use rusoto_core::request::HttpDispatchError;
use rusoto_core::signature::SignedRequest;
use serde_json;
use serde_json::from_slice;
use serde_json::Value as SerdeJsonValue;
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AddAttributesToFindingsRequest {
#[serde(rename = "attributes")]
pub attributes: Vec<Attribute>,
#[serde(rename = "findingArns")]
pub finding_arns: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AddAttributesToFindingsResponse {
#[serde(rename = "failedItems")]
pub failed_items: ::std::collections::HashMap<String, FailedItemDetails>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct AgentAlreadyRunningAssessment {
pub agent_id: String,
pub assessment_run_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AgentFilter {
#[serde(rename = "agentHealthCodes")]
pub agent_health_codes: Vec<String>,
#[serde(rename = "agentHealths")]
pub agent_healths: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AgentPreview {
#[serde(rename = "agentHealth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_health: Option<String>,
#[serde(rename = "agentId")]
pub agent_id: String,
#[serde(rename = "agentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_version: Option<String>,
#[serde(rename = "autoScalingGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_group: Option<String>,
#[serde(rename = "hostname")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hostname: Option<String>,
#[serde(rename = "ipv4Address")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ipv_4_address: Option<String>,
#[serde(rename = "kernelVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kernel_version: Option<String>,
#[serde(rename = "operatingSystem")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operating_system: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssessmentRun {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "assessmentTemplateArn")]
pub assessment_template_arn: String,
#[serde(rename = "completedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completed_at: Option<f64>,
#[serde(rename = "createdAt")]
pub created_at: f64,
#[serde(rename = "dataCollected")]
pub data_collected: bool,
#[serde(rename = "durationInSeconds")]
pub duration_in_seconds: i64,
#[serde(rename = "findingCounts")]
pub finding_counts: ::std::collections::HashMap<String, i64>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "notifications")]
pub notifications: Vec<AssessmentRunNotification>,
#[serde(rename = "rulesPackageArns")]
pub rules_package_arns: Vec<String>,
#[serde(rename = "startedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub started_at: Option<f64>,
#[serde(rename = "state")]
pub state: String,
#[serde(rename = "stateChangedAt")]
pub state_changed_at: f64,
#[serde(rename = "stateChanges")]
pub state_changes: Vec<AssessmentRunStateChange>,
#[serde(rename = "userAttributesForFindings")]
pub user_attributes_for_findings: Vec<Attribute>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssessmentRunAgent {
#[serde(rename = "agentHealth")]
pub agent_health: String,
#[serde(rename = "agentHealthCode")]
pub agent_health_code: String,
#[serde(rename = "agentHealthDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_health_details: Option<String>,
#[serde(rename = "agentId")]
pub agent_id: String,
#[serde(rename = "assessmentRunArn")]
pub assessment_run_arn: String,
#[serde(rename = "autoScalingGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_group: Option<String>,
#[serde(rename = "telemetryMetadata")]
pub telemetry_metadata: Vec<TelemetryMetadata>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AssessmentRunFilter {
#[serde(rename = "completionTimeRange")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_time_range: Option<TimestampRange>,
#[serde(rename = "durationRange")]
#[serde(skip_serializing_if = "Option::is_none")]
pub duration_range: Option<DurationRange>,
#[serde(rename = "namePattern")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name_pattern: Option<String>,
#[serde(rename = "rulesPackageArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rules_package_arns: Option<Vec<String>>,
#[serde(rename = "startTimeRange")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time_range: Option<TimestampRange>,
#[serde(rename = "stateChangeTimeRange")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_change_time_range: Option<TimestampRange>,
#[serde(rename = "states")]
#[serde(skip_serializing_if = "Option::is_none")]
pub states: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssessmentRunNotification {
#[serde(rename = "date")]
pub date: f64,
#[serde(rename = "error")]
pub error: bool,
#[serde(rename = "event")]
pub event: String,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "snsPublishStatusCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_publish_status_code: Option<String>,
#[serde(rename = "snsTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_topic_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssessmentRunStateChange {
#[serde(rename = "state")]
pub state: String,
#[serde(rename = "stateChangedAt")]
pub state_changed_at: f64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssessmentTarget {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "createdAt")]
pub created_at: f64,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "resourceGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_group_arn: Option<String>,
#[serde(rename = "updatedAt")]
pub updated_at: f64,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AssessmentTargetFilter {
#[serde(rename = "assessmentTargetNamePattern")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assessment_target_name_pattern: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssessmentTemplate {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "assessmentRunCount")]
pub assessment_run_count: i64,
#[serde(rename = "assessmentTargetArn")]
pub assessment_target_arn: String,
#[serde(rename = "createdAt")]
pub created_at: f64,
#[serde(rename = "durationInSeconds")]
pub duration_in_seconds: i64,
#[serde(rename = "lastAssessmentRunArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_assessment_run_arn: Option<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "rulesPackageArns")]
pub rules_package_arns: Vec<String>,
#[serde(rename = "userAttributesForFindings")]
pub user_attributes_for_findings: Vec<Attribute>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AssessmentTemplateFilter {
#[serde(rename = "durationRange")]
#[serde(skip_serializing_if = "Option::is_none")]
pub duration_range: Option<DurationRange>,
#[serde(rename = "namePattern")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name_pattern: Option<String>,
#[serde(rename = "rulesPackageArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rules_package_arns: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssetAttributes {
#[serde(rename = "agentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_id: Option<String>,
#[serde(rename = "amiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ami_id: Option<String>,
#[serde(rename = "autoScalingGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_group: Option<String>,
#[serde(rename = "hostname")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hostname: Option<String>,
#[serde(rename = "ipv4Addresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ipv_4_addresses: Option<Vec<String>>,
#[serde(rename = "networkInterfaces")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_interfaces: Option<Vec<NetworkInterface>>,
#[serde(rename = "schemaVersion")]
pub schema_version: i64,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Attribute {
#[serde(rename = "key")]
pub key: String,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateAssessmentTargetRequest {
#[serde(rename = "assessmentTargetName")]
pub assessment_target_name: String,
#[serde(rename = "resourceGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_group_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateAssessmentTargetResponse {
#[serde(rename = "assessmentTargetArn")]
pub assessment_target_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateAssessmentTemplateRequest {
#[serde(rename = "assessmentTargetArn")]
pub assessment_target_arn: String,
#[serde(rename = "assessmentTemplateName")]
pub assessment_template_name: String,
#[serde(rename = "durationInSeconds")]
pub duration_in_seconds: i64,
#[serde(rename = "rulesPackageArns")]
pub rules_package_arns: Vec<String>,
#[serde(rename = "userAttributesForFindings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_attributes_for_findings: Option<Vec<Attribute>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateAssessmentTemplateResponse {
#[serde(rename = "assessmentTemplateArn")]
pub assessment_template_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateExclusionsPreviewRequest {
#[serde(rename = "assessmentTemplateArn")]
pub assessment_template_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateExclusionsPreviewResponse {
#[serde(rename = "previewToken")]
pub preview_token: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateResourceGroupRequest {
#[serde(rename = "resourceGroupTags")]
pub resource_group_tags: Vec<ResourceGroupTag>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateResourceGroupResponse {
#[serde(rename = "resourceGroupArn")]
pub resource_group_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteAssessmentRunRequest {
#[serde(rename = "assessmentRunArn")]
pub assessment_run_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteAssessmentTargetRequest {
#[serde(rename = "assessmentTargetArn")]
pub assessment_target_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteAssessmentTemplateRequest {
#[serde(rename = "assessmentTemplateArn")]
pub assessment_template_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeAssessmentRunsRequest {
#[serde(rename = "assessmentRunArns")]
pub assessment_run_arns: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeAssessmentRunsResponse {
#[serde(rename = "assessmentRuns")]
pub assessment_runs: Vec<AssessmentRun>,
#[serde(rename = "failedItems")]
pub failed_items: ::std::collections::HashMap<String, FailedItemDetails>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeAssessmentTargetsRequest {
#[serde(rename = "assessmentTargetArns")]
pub assessment_target_arns: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeAssessmentTargetsResponse {
#[serde(rename = "assessmentTargets")]
pub assessment_targets: Vec<AssessmentTarget>,
#[serde(rename = "failedItems")]
pub failed_items: ::std::collections::HashMap<String, FailedItemDetails>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeAssessmentTemplatesRequest {
#[serde(rename = "assessmentTemplateArns")]
pub assessment_template_arns: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeAssessmentTemplatesResponse {
#[serde(rename = "assessmentTemplates")]
pub assessment_templates: Vec<AssessmentTemplate>,
#[serde(rename = "failedItems")]
pub failed_items: ::std::collections::HashMap<String, FailedItemDetails>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeCrossAccountAccessRoleResponse {
#[serde(rename = "registeredAt")]
pub registered_at: f64,
#[serde(rename = "roleArn")]
pub role_arn: String,
#[serde(rename = "valid")]
pub valid: bool,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeExclusionsRequest {
#[serde(rename = "exclusionArns")]
pub exclusion_arns: Vec<String>,
#[serde(rename = "locale")]
#[serde(skip_serializing_if = "Option::is_none")]
pub locale: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeExclusionsResponse {
#[serde(rename = "exclusions")]
pub exclusions: ::std::collections::HashMap<String, Exclusion>,
#[serde(rename = "failedItems")]
pub failed_items: ::std::collections::HashMap<String, FailedItemDetails>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeFindingsRequest {
#[serde(rename = "findingArns")]
pub finding_arns: Vec<String>,
#[serde(rename = "locale")]
#[serde(skip_serializing_if = "Option::is_none")]
pub locale: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeFindingsResponse {
#[serde(rename = "failedItems")]
pub failed_items: ::std::collections::HashMap<String, FailedItemDetails>,
#[serde(rename = "findings")]
pub findings: Vec<Finding>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeResourceGroupsRequest {
#[serde(rename = "resourceGroupArns")]
pub resource_group_arns: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeResourceGroupsResponse {
#[serde(rename = "failedItems")]
pub failed_items: ::std::collections::HashMap<String, FailedItemDetails>,
#[serde(rename = "resourceGroups")]
pub resource_groups: Vec<ResourceGroup>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeRulesPackagesRequest {
#[serde(rename = "locale")]
#[serde(skip_serializing_if = "Option::is_none")]
pub locale: Option<String>,
#[serde(rename = "rulesPackageArns")]
pub rules_package_arns: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeRulesPackagesResponse {
#[serde(rename = "failedItems")]
pub failed_items: ::std::collections::HashMap<String, FailedItemDetails>,
#[serde(rename = "rulesPackages")]
pub rules_packages: Vec<RulesPackage>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DurationRange {
#[serde(rename = "maxSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_seconds: Option<i64>,
#[serde(rename = "minSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_seconds: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct EventSubscription {
#[serde(rename = "event")]
pub event: String,
#[serde(rename = "subscribedAt")]
pub subscribed_at: f64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Exclusion {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<Attribute>>,
#[serde(rename = "description")]
pub description: String,
#[serde(rename = "recommendation")]
pub recommendation: String,
#[serde(rename = "scopes")]
pub scopes: Vec<Scope>,
#[serde(rename = "title")]
pub title: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ExclusionPreview {
#[serde(rename = "attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<Attribute>>,
#[serde(rename = "description")]
pub description: String,
#[serde(rename = "recommendation")]
pub recommendation: String,
#[serde(rename = "scopes")]
pub scopes: Vec<Scope>,
#[serde(rename = "title")]
pub title: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct FailedItemDetails {
#[serde(rename = "failureCode")]
pub failure_code: String,
#[serde(rename = "retryable")]
pub retryable: bool,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Finding {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "assetAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub asset_attributes: Option<AssetAttributes>,
#[serde(rename = "assetType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub asset_type: Option<String>,
#[serde(rename = "attributes")]
pub attributes: Vec<Attribute>,
#[serde(rename = "confidence")]
#[serde(skip_serializing_if = "Option::is_none")]
pub confidence: Option<i64>,
#[serde(rename = "createdAt")]
pub created_at: f64,
#[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 = "indicatorOfCompromise")]
#[serde(skip_serializing_if = "Option::is_none")]
pub indicator_of_compromise: Option<bool>,
#[serde(rename = "numericSeverity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub numeric_severity: Option<f64>,
#[serde(rename = "recommendation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recommendation: Option<String>,
#[serde(rename = "schemaVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_version: Option<i64>,
#[serde(rename = "service")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service: Option<String>,
#[serde(rename = "serviceAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_attributes: Option<InspectorServiceAttributes>,
#[serde(rename = "severity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub severity: Option<String>,
#[serde(rename = "title")]
#[serde(skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
#[serde(rename = "updatedAt")]
pub updated_at: f64,
#[serde(rename = "userAttributes")]
pub user_attributes: Vec<Attribute>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct FindingFilter {
#[serde(rename = "agentIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_ids: Option<Vec<String>>,
#[serde(rename = "attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<Attribute>>,
#[serde(rename = "autoScalingGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_groups: Option<Vec<String>>,
#[serde(rename = "creationTimeRange")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time_range: Option<TimestampRange>,
#[serde(rename = "ruleNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rule_names: Option<Vec<String>>,
#[serde(rename = "rulesPackageArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rules_package_arns: Option<Vec<String>>,
#[serde(rename = "severities")]
#[serde(skip_serializing_if = "Option::is_none")]
pub severities: Option<Vec<String>>,
#[serde(rename = "userAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_attributes: Option<Vec<Attribute>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetAssessmentReportRequest {
#[serde(rename = "assessmentRunArn")]
pub assessment_run_arn: String,
#[serde(rename = "reportFileFormat")]
pub report_file_format: String,
#[serde(rename = "reportType")]
pub report_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetAssessmentReportResponse {
#[serde(rename = "status")]
pub status: String,
#[serde(rename = "url")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetExclusionsPreviewRequest {
#[serde(rename = "assessmentTemplateArn")]
pub assessment_template_arn: String,
#[serde(rename = "locale")]
#[serde(skip_serializing_if = "Option::is_none")]
pub locale: 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 = "previewToken")]
pub preview_token: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetExclusionsPreviewResponse {
#[serde(rename = "exclusionPreviews")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclusion_previews: Option<Vec<ExclusionPreview>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "previewStatus")]
pub preview_status: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct GetTelemetryMetadataRequest {
#[serde(rename = "assessmentRunArn")]
pub assessment_run_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct GetTelemetryMetadataResponse {
#[serde(rename = "telemetryMetadata")]
pub telemetry_metadata: Vec<TelemetryMetadata>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct InspectorServiceAttributes {
#[serde(rename = "assessmentRunArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assessment_run_arn: Option<String>,
#[serde(rename = "rulesPackageArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rules_package_arn: Option<String>,
#[serde(rename = "schemaVersion")]
pub schema_version: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListAssessmentRunAgentsRequest {
#[serde(rename = "assessmentRunArn")]
pub assessment_run_arn: String,
#[serde(rename = "filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<AgentFilter>,
#[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 ListAssessmentRunAgentsResponse {
#[serde(rename = "assessmentRunAgents")]
pub assessment_run_agents: Vec<AssessmentRunAgent>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListAssessmentRunsRequest {
#[serde(rename = "assessmentTemplateArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assessment_template_arns: Option<Vec<String>>,
#[serde(rename = "filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<AssessmentRunFilter>,
#[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 ListAssessmentRunsResponse {
#[serde(rename = "assessmentRunArns")]
pub assessment_run_arns: Vec<String>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListAssessmentTargetsRequest {
#[serde(rename = "filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<AssessmentTargetFilter>,
#[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 ListAssessmentTargetsResponse {
#[serde(rename = "assessmentTargetArns")]
pub assessment_target_arns: Vec<String>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListAssessmentTemplatesRequest {
#[serde(rename = "assessmentTargetArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assessment_target_arns: Option<Vec<String>>,
#[serde(rename = "filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<AssessmentTemplateFilter>,
#[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 ListAssessmentTemplatesResponse {
#[serde(rename = "assessmentTemplateArns")]
pub assessment_template_arns: Vec<String>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListEventSubscriptionsRequest {
#[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 = "resourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListEventSubscriptionsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "subscriptions")]
pub subscriptions: Vec<Subscription>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListExclusionsRequest {
#[serde(rename = "assessmentRunArn")]
pub assessment_run_arn: 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 ListExclusionsResponse {
#[serde(rename = "exclusionArns")]
pub exclusion_arns: Vec<String>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListFindingsRequest {
#[serde(rename = "assessmentRunArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assessment_run_arns: Option<Vec<String>>,
#[serde(rename = "filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<FindingFilter>,
#[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 ListFindingsResponse {
#[serde(rename = "findingArns")]
pub finding_arns: Vec<String>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListRulesPackagesRequest {
#[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 ListRulesPackagesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "rulesPackageArns")]
pub rules_package_arns: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListTagsForResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "tags")]
pub tags: Vec<Tag>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct NetworkInterface {
#[serde(rename = "ipv6Addresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ipv_6_addresses: Option<Vec<String>>,
#[serde(rename = "networkInterfaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_interface_id: Option<String>,
#[serde(rename = "privateDnsName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_dns_name: Option<String>,
#[serde(rename = "privateIpAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_ip_address: Option<String>,
#[serde(rename = "privateIpAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_ip_addresses: Option<Vec<PrivateIp>>,
#[serde(rename = "publicDnsName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_dns_name: Option<String>,
#[serde(rename = "publicIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_ip: Option<String>,
#[serde(rename = "securityGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_groups: Option<Vec<SecurityGroup>>,
#[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>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct PreviewAgentsRequest {
#[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 = "previewAgentsArn")]
pub preview_agents_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct PreviewAgentsResponse {
#[serde(rename = "agentPreviews")]
pub agent_previews: Vec<AgentPreview>,
#[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 PrivateIp {
#[serde(rename = "privateDnsName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_dns_name: Option<String>,
#[serde(rename = "privateIpAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_ip_address: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RegisterCrossAccountAccessRoleRequest {
#[serde(rename = "roleArn")]
pub role_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RemoveAttributesFromFindingsRequest {
#[serde(rename = "attributeKeys")]
pub attribute_keys: Vec<String>,
#[serde(rename = "findingArns")]
pub finding_arns: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RemoveAttributesFromFindingsResponse {
#[serde(rename = "failedItems")]
pub failed_items: ::std::collections::HashMap<String, FailedItemDetails>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ResourceGroup {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "createdAt")]
pub created_at: f64,
#[serde(rename = "tags")]
pub tags: Vec<ResourceGroupTag>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ResourceGroupTag {
#[serde(rename = "key")]
pub key: String,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RulesPackage {
#[serde(rename = "arn")]
pub arn: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "provider")]
pub provider: String,
#[serde(rename = "version")]
pub version: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Scope {
#[serde(rename = "key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct SecurityGroup {
#[serde(rename = "groupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
#[serde(rename = "groupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct SetTagsForResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StartAssessmentRunRequest {
#[serde(rename = "assessmentRunName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assessment_run_name: Option<String>,
#[serde(rename = "assessmentTemplateArn")]
pub assessment_template_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct StartAssessmentRunResponse {
#[serde(rename = "assessmentRunArn")]
pub assessment_run_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct StopAssessmentRunRequest {
#[serde(rename = "assessmentRunArn")]
pub assessment_run_arn: String,
#[serde(rename = "stopAction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stop_action: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct SubscribeToEventRequest {
#[serde(rename = "event")]
pub event: String,
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "topicArn")]
pub topic_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Subscription {
#[serde(rename = "eventSubscriptions")]
pub event_subscriptions: Vec<EventSubscription>,
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "topicArn")]
pub topic_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Tag {
#[serde(rename = "key")]
pub key: String,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct TelemetryMetadata {
#[serde(rename = "count")]
pub count: i64,
#[serde(rename = "dataSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_size: Option<i64>,
#[serde(rename = "messageType")]
pub message_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct TimestampRange {
#[serde(rename = "beginDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub begin_date: Option<f64>,
#[serde(rename = "endDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_date: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UnsubscribeFromEventRequest {
#[serde(rename = "event")]
pub event: String,
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "topicArn")]
pub topic_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateAssessmentTargetRequest {
#[serde(rename = "assessmentTargetArn")]
pub assessment_target_arn: String,
#[serde(rename = "assessmentTargetName")]
pub assessment_target_name: String,
#[serde(rename = "resourceGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_group_arn: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AddAttributesToFindingsError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AddAttributesToFindingsError {
pub fn from_response(res: BufferedHttpResponse) -> AddAttributesToFindingsError {
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 AddAttributesToFindingsError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return AddAttributesToFindingsError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return AddAttributesToFindingsError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return AddAttributesToFindingsError::NoSuchEntity(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return AddAttributesToFindingsError::ServiceTemporarilyUnavailable(
String::from(error_message),
);
}
"ValidationException" => {
return AddAttributesToFindingsError::Validation(error_message.to_string());
}
_ => {}
}
}
return AddAttributesToFindingsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AddAttributesToFindingsError {
fn from(err: serde_json::error::Error) -> AddAttributesToFindingsError {
AddAttributesToFindingsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AddAttributesToFindingsError {
fn from(err: CredentialsError) -> AddAttributesToFindingsError {
AddAttributesToFindingsError::Credentials(err)
}
}
impl From<HttpDispatchError> for AddAttributesToFindingsError {
fn from(err: HttpDispatchError) -> AddAttributesToFindingsError {
AddAttributesToFindingsError::HttpDispatch(err)
}
}
impl From<io::Error> for AddAttributesToFindingsError {
fn from(err: io::Error) -> AddAttributesToFindingsError {
AddAttributesToFindingsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AddAttributesToFindingsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AddAttributesToFindingsError {
fn description(&self) -> &str {
match *self {
AddAttributesToFindingsError::AccessDenied(ref cause) => cause,
AddAttributesToFindingsError::Internal(ref cause) => cause,
AddAttributesToFindingsError::InvalidInput(ref cause) => cause,
AddAttributesToFindingsError::NoSuchEntity(ref cause) => cause,
AddAttributesToFindingsError::ServiceTemporarilyUnavailable(ref cause) => cause,
AddAttributesToFindingsError::Validation(ref cause) => cause,
AddAttributesToFindingsError::Credentials(ref err) => err.description(),
AddAttributesToFindingsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AddAttributesToFindingsError::ParseError(ref cause) => cause,
AddAttributesToFindingsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateAssessmentTargetError {
AccessDenied(String),
Internal(String),
InvalidCrossAccountRole(String),
InvalidInput(String),
LimitExceeded(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateAssessmentTargetError {
pub fn from_response(res: BufferedHttpResponse) -> CreateAssessmentTargetError {
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 CreateAssessmentTargetError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return CreateAssessmentTargetError::Internal(String::from(error_message));
}
"InvalidCrossAccountRoleException" => {
return CreateAssessmentTargetError::InvalidCrossAccountRole(String::from(
error_message,
));
}
"InvalidInputException" => {
return CreateAssessmentTargetError::InvalidInput(String::from(error_message));
}
"LimitExceededException" => {
return CreateAssessmentTargetError::LimitExceeded(String::from(error_message));
}
"NoSuchEntityException" => {
return CreateAssessmentTargetError::NoSuchEntity(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return CreateAssessmentTargetError::ServiceTemporarilyUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return CreateAssessmentTargetError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateAssessmentTargetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateAssessmentTargetError {
fn from(err: serde_json::error::Error) -> CreateAssessmentTargetError {
CreateAssessmentTargetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateAssessmentTargetError {
fn from(err: CredentialsError) -> CreateAssessmentTargetError {
CreateAssessmentTargetError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateAssessmentTargetError {
fn from(err: HttpDispatchError) -> CreateAssessmentTargetError {
CreateAssessmentTargetError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateAssessmentTargetError {
fn from(err: io::Error) -> CreateAssessmentTargetError {
CreateAssessmentTargetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateAssessmentTargetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateAssessmentTargetError {
fn description(&self) -> &str {
match *self {
CreateAssessmentTargetError::AccessDenied(ref cause) => cause,
CreateAssessmentTargetError::Internal(ref cause) => cause,
CreateAssessmentTargetError::InvalidCrossAccountRole(ref cause) => cause,
CreateAssessmentTargetError::InvalidInput(ref cause) => cause,
CreateAssessmentTargetError::LimitExceeded(ref cause) => cause,
CreateAssessmentTargetError::NoSuchEntity(ref cause) => cause,
CreateAssessmentTargetError::ServiceTemporarilyUnavailable(ref cause) => cause,
CreateAssessmentTargetError::Validation(ref cause) => cause,
CreateAssessmentTargetError::Credentials(ref err) => err.description(),
CreateAssessmentTargetError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateAssessmentTargetError::ParseError(ref cause) => cause,
CreateAssessmentTargetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateAssessmentTemplateError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
LimitExceeded(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateAssessmentTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> CreateAssessmentTemplateError {
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 CreateAssessmentTemplateError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return CreateAssessmentTemplateError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return CreateAssessmentTemplateError::InvalidInput(String::from(error_message));
}
"LimitExceededException" => {
return CreateAssessmentTemplateError::LimitExceeded(String::from(error_message));
}
"NoSuchEntityException" => {
return CreateAssessmentTemplateError::NoSuchEntity(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return CreateAssessmentTemplateError::ServiceTemporarilyUnavailable(
String::from(error_message),
);
}
"ValidationException" => {
return CreateAssessmentTemplateError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateAssessmentTemplateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateAssessmentTemplateError {
fn from(err: serde_json::error::Error) -> CreateAssessmentTemplateError {
CreateAssessmentTemplateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateAssessmentTemplateError {
fn from(err: CredentialsError) -> CreateAssessmentTemplateError {
CreateAssessmentTemplateError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateAssessmentTemplateError {
fn from(err: HttpDispatchError) -> CreateAssessmentTemplateError {
CreateAssessmentTemplateError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateAssessmentTemplateError {
fn from(err: io::Error) -> CreateAssessmentTemplateError {
CreateAssessmentTemplateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateAssessmentTemplateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateAssessmentTemplateError {
fn description(&self) -> &str {
match *self {
CreateAssessmentTemplateError::AccessDenied(ref cause) => cause,
CreateAssessmentTemplateError::Internal(ref cause) => cause,
CreateAssessmentTemplateError::InvalidInput(ref cause) => cause,
CreateAssessmentTemplateError::LimitExceeded(ref cause) => cause,
CreateAssessmentTemplateError::NoSuchEntity(ref cause) => cause,
CreateAssessmentTemplateError::ServiceTemporarilyUnavailable(ref cause) => cause,
CreateAssessmentTemplateError::Validation(ref cause) => cause,
CreateAssessmentTemplateError::Credentials(ref err) => err.description(),
CreateAssessmentTemplateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateAssessmentTemplateError::ParseError(ref cause) => cause,
CreateAssessmentTemplateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateExclusionsPreviewError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
PreviewGenerationInProgress(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateExclusionsPreviewError {
pub fn from_response(res: BufferedHttpResponse) -> CreateExclusionsPreviewError {
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 CreateExclusionsPreviewError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return CreateExclusionsPreviewError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return CreateExclusionsPreviewError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return CreateExclusionsPreviewError::NoSuchEntity(String::from(error_message));
}
"PreviewGenerationInProgressException" => {
return CreateExclusionsPreviewError::PreviewGenerationInProgress(String::from(
error_message,
));
}
"ServiceTemporarilyUnavailableException" => {
return CreateExclusionsPreviewError::ServiceTemporarilyUnavailable(
String::from(error_message),
);
}
"ValidationException" => {
return CreateExclusionsPreviewError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateExclusionsPreviewError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateExclusionsPreviewError {
fn from(err: serde_json::error::Error) -> CreateExclusionsPreviewError {
CreateExclusionsPreviewError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateExclusionsPreviewError {
fn from(err: CredentialsError) -> CreateExclusionsPreviewError {
CreateExclusionsPreviewError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateExclusionsPreviewError {
fn from(err: HttpDispatchError) -> CreateExclusionsPreviewError {
CreateExclusionsPreviewError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateExclusionsPreviewError {
fn from(err: io::Error) -> CreateExclusionsPreviewError {
CreateExclusionsPreviewError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateExclusionsPreviewError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateExclusionsPreviewError {
fn description(&self) -> &str {
match *self {
CreateExclusionsPreviewError::AccessDenied(ref cause) => cause,
CreateExclusionsPreviewError::Internal(ref cause) => cause,
CreateExclusionsPreviewError::InvalidInput(ref cause) => cause,
CreateExclusionsPreviewError::NoSuchEntity(ref cause) => cause,
CreateExclusionsPreviewError::PreviewGenerationInProgress(ref cause) => cause,
CreateExclusionsPreviewError::ServiceTemporarilyUnavailable(ref cause) => cause,
CreateExclusionsPreviewError::Validation(ref cause) => cause,
CreateExclusionsPreviewError::Credentials(ref err) => err.description(),
CreateExclusionsPreviewError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateExclusionsPreviewError::ParseError(ref cause) => cause,
CreateExclusionsPreviewError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateResourceGroupError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
LimitExceeded(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateResourceGroupError {
pub fn from_response(res: BufferedHttpResponse) -> CreateResourceGroupError {
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 CreateResourceGroupError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return CreateResourceGroupError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return CreateResourceGroupError::InvalidInput(String::from(error_message));
}
"LimitExceededException" => {
return CreateResourceGroupError::LimitExceeded(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return CreateResourceGroupError::ServiceTemporarilyUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return CreateResourceGroupError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateResourceGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateResourceGroupError {
fn from(err: serde_json::error::Error) -> CreateResourceGroupError {
CreateResourceGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateResourceGroupError {
fn from(err: CredentialsError) -> CreateResourceGroupError {
CreateResourceGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateResourceGroupError {
fn from(err: HttpDispatchError) -> CreateResourceGroupError {
CreateResourceGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateResourceGroupError {
fn from(err: io::Error) -> CreateResourceGroupError {
CreateResourceGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateResourceGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateResourceGroupError {
fn description(&self) -> &str {
match *self {
CreateResourceGroupError::AccessDenied(ref cause) => cause,
CreateResourceGroupError::Internal(ref cause) => cause,
CreateResourceGroupError::InvalidInput(ref cause) => cause,
CreateResourceGroupError::LimitExceeded(ref cause) => cause,
CreateResourceGroupError::ServiceTemporarilyUnavailable(ref cause) => cause,
CreateResourceGroupError::Validation(ref cause) => cause,
CreateResourceGroupError::Credentials(ref err) => err.description(),
CreateResourceGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
CreateResourceGroupError::ParseError(ref cause) => cause,
CreateResourceGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteAssessmentRunError {
AccessDenied(String),
AssessmentRunInProgress(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteAssessmentRunError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteAssessmentRunError {
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 DeleteAssessmentRunError::AccessDenied(String::from(error_message));
}
"AssessmentRunInProgressException" => {
return DeleteAssessmentRunError::AssessmentRunInProgress(String::from(
error_message,
));
}
"InternalException" => {
return DeleteAssessmentRunError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return DeleteAssessmentRunError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return DeleteAssessmentRunError::NoSuchEntity(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return DeleteAssessmentRunError::ServiceTemporarilyUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return DeleteAssessmentRunError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteAssessmentRunError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteAssessmentRunError {
fn from(err: serde_json::error::Error) -> DeleteAssessmentRunError {
DeleteAssessmentRunError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteAssessmentRunError {
fn from(err: CredentialsError) -> DeleteAssessmentRunError {
DeleteAssessmentRunError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteAssessmentRunError {
fn from(err: HttpDispatchError) -> DeleteAssessmentRunError {
DeleteAssessmentRunError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteAssessmentRunError {
fn from(err: io::Error) -> DeleteAssessmentRunError {
DeleteAssessmentRunError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteAssessmentRunError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteAssessmentRunError {
fn description(&self) -> &str {
match *self {
DeleteAssessmentRunError::AccessDenied(ref cause) => cause,
DeleteAssessmentRunError::AssessmentRunInProgress(ref cause) => cause,
DeleteAssessmentRunError::Internal(ref cause) => cause,
DeleteAssessmentRunError::InvalidInput(ref cause) => cause,
DeleteAssessmentRunError::NoSuchEntity(ref cause) => cause,
DeleteAssessmentRunError::ServiceTemporarilyUnavailable(ref cause) => cause,
DeleteAssessmentRunError::Validation(ref cause) => cause,
DeleteAssessmentRunError::Credentials(ref err) => err.description(),
DeleteAssessmentRunError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteAssessmentRunError::ParseError(ref cause) => cause,
DeleteAssessmentRunError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteAssessmentTargetError {
AccessDenied(String),
AssessmentRunInProgress(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteAssessmentTargetError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteAssessmentTargetError {
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 DeleteAssessmentTargetError::AccessDenied(String::from(error_message));
}
"AssessmentRunInProgressException" => {
return DeleteAssessmentTargetError::AssessmentRunInProgress(String::from(
error_message,
));
}
"InternalException" => {
return DeleteAssessmentTargetError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return DeleteAssessmentTargetError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return DeleteAssessmentTargetError::NoSuchEntity(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return DeleteAssessmentTargetError::ServiceTemporarilyUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return DeleteAssessmentTargetError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteAssessmentTargetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteAssessmentTargetError {
fn from(err: serde_json::error::Error) -> DeleteAssessmentTargetError {
DeleteAssessmentTargetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteAssessmentTargetError {
fn from(err: CredentialsError) -> DeleteAssessmentTargetError {
DeleteAssessmentTargetError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteAssessmentTargetError {
fn from(err: HttpDispatchError) -> DeleteAssessmentTargetError {
DeleteAssessmentTargetError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteAssessmentTargetError {
fn from(err: io::Error) -> DeleteAssessmentTargetError {
DeleteAssessmentTargetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteAssessmentTargetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteAssessmentTargetError {
fn description(&self) -> &str {
match *self {
DeleteAssessmentTargetError::AccessDenied(ref cause) => cause,
DeleteAssessmentTargetError::AssessmentRunInProgress(ref cause) => cause,
DeleteAssessmentTargetError::Internal(ref cause) => cause,
DeleteAssessmentTargetError::InvalidInput(ref cause) => cause,
DeleteAssessmentTargetError::NoSuchEntity(ref cause) => cause,
DeleteAssessmentTargetError::ServiceTemporarilyUnavailable(ref cause) => cause,
DeleteAssessmentTargetError::Validation(ref cause) => cause,
DeleteAssessmentTargetError::Credentials(ref err) => err.description(),
DeleteAssessmentTargetError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteAssessmentTargetError::ParseError(ref cause) => cause,
DeleteAssessmentTargetError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteAssessmentTemplateError {
AccessDenied(String),
AssessmentRunInProgress(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteAssessmentTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteAssessmentTemplateError {
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 DeleteAssessmentTemplateError::AccessDenied(String::from(error_message));
}
"AssessmentRunInProgressException" => {
return DeleteAssessmentTemplateError::AssessmentRunInProgress(String::from(
error_message,
));
}
"InternalException" => {
return DeleteAssessmentTemplateError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return DeleteAssessmentTemplateError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return DeleteAssessmentTemplateError::NoSuchEntity(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return DeleteAssessmentTemplateError::ServiceTemporarilyUnavailable(
String::from(error_message),
);
}
"ValidationException" => {
return DeleteAssessmentTemplateError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteAssessmentTemplateError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteAssessmentTemplateError {
fn from(err: serde_json::error::Error) -> DeleteAssessmentTemplateError {
DeleteAssessmentTemplateError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteAssessmentTemplateError {
fn from(err: CredentialsError) -> DeleteAssessmentTemplateError {
DeleteAssessmentTemplateError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteAssessmentTemplateError {
fn from(err: HttpDispatchError) -> DeleteAssessmentTemplateError {
DeleteAssessmentTemplateError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteAssessmentTemplateError {
fn from(err: io::Error) -> DeleteAssessmentTemplateError {
DeleteAssessmentTemplateError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteAssessmentTemplateError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteAssessmentTemplateError {
fn description(&self) -> &str {
match *self {
DeleteAssessmentTemplateError::AccessDenied(ref cause) => cause,
DeleteAssessmentTemplateError::AssessmentRunInProgress(ref cause) => cause,
DeleteAssessmentTemplateError::Internal(ref cause) => cause,
DeleteAssessmentTemplateError::InvalidInput(ref cause) => cause,
DeleteAssessmentTemplateError::NoSuchEntity(ref cause) => cause,
DeleteAssessmentTemplateError::ServiceTemporarilyUnavailable(ref cause) => cause,
DeleteAssessmentTemplateError::Validation(ref cause) => cause,
DeleteAssessmentTemplateError::Credentials(ref err) => err.description(),
DeleteAssessmentTemplateError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteAssessmentTemplateError::ParseError(ref cause) => cause,
DeleteAssessmentTemplateError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAssessmentRunsError {
Internal(String),
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAssessmentRunsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAssessmentRunsError {
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 {
"InternalException" => {
return DescribeAssessmentRunsError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return DescribeAssessmentRunsError::InvalidInput(String::from(error_message));
}
"ValidationException" => {
return DescribeAssessmentRunsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeAssessmentRunsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeAssessmentRunsError {
fn from(err: serde_json::error::Error) -> DescribeAssessmentRunsError {
DescribeAssessmentRunsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeAssessmentRunsError {
fn from(err: CredentialsError) -> DescribeAssessmentRunsError {
DescribeAssessmentRunsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAssessmentRunsError {
fn from(err: HttpDispatchError) -> DescribeAssessmentRunsError {
DescribeAssessmentRunsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAssessmentRunsError {
fn from(err: io::Error) -> DescribeAssessmentRunsError {
DescribeAssessmentRunsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAssessmentRunsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAssessmentRunsError {
fn description(&self) -> &str {
match *self {
DescribeAssessmentRunsError::Internal(ref cause) => cause,
DescribeAssessmentRunsError::InvalidInput(ref cause) => cause,
DescribeAssessmentRunsError::Validation(ref cause) => cause,
DescribeAssessmentRunsError::Credentials(ref err) => err.description(),
DescribeAssessmentRunsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAssessmentRunsError::ParseError(ref cause) => cause,
DescribeAssessmentRunsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAssessmentTargetsError {
Internal(String),
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAssessmentTargetsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAssessmentTargetsError {
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 {
"InternalException" => {
return DescribeAssessmentTargetsError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return DescribeAssessmentTargetsError::InvalidInput(String::from(error_message));
}
"ValidationException" => {
return DescribeAssessmentTargetsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeAssessmentTargetsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeAssessmentTargetsError {
fn from(err: serde_json::error::Error) -> DescribeAssessmentTargetsError {
DescribeAssessmentTargetsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeAssessmentTargetsError {
fn from(err: CredentialsError) -> DescribeAssessmentTargetsError {
DescribeAssessmentTargetsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAssessmentTargetsError {
fn from(err: HttpDispatchError) -> DescribeAssessmentTargetsError {
DescribeAssessmentTargetsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAssessmentTargetsError {
fn from(err: io::Error) -> DescribeAssessmentTargetsError {
DescribeAssessmentTargetsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAssessmentTargetsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAssessmentTargetsError {
fn description(&self) -> &str {
match *self {
DescribeAssessmentTargetsError::Internal(ref cause) => cause,
DescribeAssessmentTargetsError::InvalidInput(ref cause) => cause,
DescribeAssessmentTargetsError::Validation(ref cause) => cause,
DescribeAssessmentTargetsError::Credentials(ref err) => err.description(),
DescribeAssessmentTargetsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAssessmentTargetsError::ParseError(ref cause) => cause,
DescribeAssessmentTargetsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeAssessmentTemplatesError {
Internal(String),
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeAssessmentTemplatesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeAssessmentTemplatesError {
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 {
"InternalException" => {
return DescribeAssessmentTemplatesError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return DescribeAssessmentTemplatesError::InvalidInput(String::from(
error_message,
));
}
"ValidationException" => {
return DescribeAssessmentTemplatesError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeAssessmentTemplatesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeAssessmentTemplatesError {
fn from(err: serde_json::error::Error) -> DescribeAssessmentTemplatesError {
DescribeAssessmentTemplatesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeAssessmentTemplatesError {
fn from(err: CredentialsError) -> DescribeAssessmentTemplatesError {
DescribeAssessmentTemplatesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeAssessmentTemplatesError {
fn from(err: HttpDispatchError) -> DescribeAssessmentTemplatesError {
DescribeAssessmentTemplatesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeAssessmentTemplatesError {
fn from(err: io::Error) -> DescribeAssessmentTemplatesError {
DescribeAssessmentTemplatesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeAssessmentTemplatesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeAssessmentTemplatesError {
fn description(&self) -> &str {
match *self {
DescribeAssessmentTemplatesError::Internal(ref cause) => cause,
DescribeAssessmentTemplatesError::InvalidInput(ref cause) => cause,
DescribeAssessmentTemplatesError::Validation(ref cause) => cause,
DescribeAssessmentTemplatesError::Credentials(ref err) => err.description(),
DescribeAssessmentTemplatesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeAssessmentTemplatesError::ParseError(ref cause) => cause,
DescribeAssessmentTemplatesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeCrossAccountAccessRoleError {
Internal(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeCrossAccountAccessRoleError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeCrossAccountAccessRoleError {
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 {
"InternalException" => {
return DescribeCrossAccountAccessRoleError::Internal(String::from(
error_message,
));
}
"ValidationException" => {
return DescribeCrossAccountAccessRoleError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return DescribeCrossAccountAccessRoleError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeCrossAccountAccessRoleError {
fn from(err: serde_json::error::Error) -> DescribeCrossAccountAccessRoleError {
DescribeCrossAccountAccessRoleError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeCrossAccountAccessRoleError {
fn from(err: CredentialsError) -> DescribeCrossAccountAccessRoleError {
DescribeCrossAccountAccessRoleError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeCrossAccountAccessRoleError {
fn from(err: HttpDispatchError) -> DescribeCrossAccountAccessRoleError {
DescribeCrossAccountAccessRoleError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeCrossAccountAccessRoleError {
fn from(err: io::Error) -> DescribeCrossAccountAccessRoleError {
DescribeCrossAccountAccessRoleError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeCrossAccountAccessRoleError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeCrossAccountAccessRoleError {
fn description(&self) -> &str {
match *self {
DescribeCrossAccountAccessRoleError::Internal(ref cause) => cause,
DescribeCrossAccountAccessRoleError::Validation(ref cause) => cause,
DescribeCrossAccountAccessRoleError::Credentials(ref err) => err.description(),
DescribeCrossAccountAccessRoleError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeCrossAccountAccessRoleError::ParseError(ref cause) => cause,
DescribeCrossAccountAccessRoleError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeExclusionsError {
Internal(String),
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeExclusionsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeExclusionsError {
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 {
"InternalException" => {
return DescribeExclusionsError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return DescribeExclusionsError::InvalidInput(String::from(error_message));
}
"ValidationException" => {
return DescribeExclusionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeExclusionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeExclusionsError {
fn from(err: serde_json::error::Error) -> DescribeExclusionsError {
DescribeExclusionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeExclusionsError {
fn from(err: CredentialsError) -> DescribeExclusionsError {
DescribeExclusionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeExclusionsError {
fn from(err: HttpDispatchError) -> DescribeExclusionsError {
DescribeExclusionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeExclusionsError {
fn from(err: io::Error) -> DescribeExclusionsError {
DescribeExclusionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeExclusionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeExclusionsError {
fn description(&self) -> &str {
match *self {
DescribeExclusionsError::Internal(ref cause) => cause,
DescribeExclusionsError::InvalidInput(ref cause) => cause,
DescribeExclusionsError::Validation(ref cause) => cause,
DescribeExclusionsError::Credentials(ref err) => err.description(),
DescribeExclusionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeExclusionsError::ParseError(ref cause) => cause,
DescribeExclusionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeFindingsError {
Internal(String),
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeFindingsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeFindingsError {
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 {
"InternalException" => {
return DescribeFindingsError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return DescribeFindingsError::InvalidInput(String::from(error_message));
}
"ValidationException" => {
return DescribeFindingsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeFindingsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeFindingsError {
fn from(err: serde_json::error::Error) -> DescribeFindingsError {
DescribeFindingsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeFindingsError {
fn from(err: CredentialsError) -> DescribeFindingsError {
DescribeFindingsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeFindingsError {
fn from(err: HttpDispatchError) -> DescribeFindingsError {
DescribeFindingsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeFindingsError {
fn from(err: io::Error) -> DescribeFindingsError {
DescribeFindingsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeFindingsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeFindingsError {
fn description(&self) -> &str {
match *self {
DescribeFindingsError::Internal(ref cause) => cause,
DescribeFindingsError::InvalidInput(ref cause) => cause,
DescribeFindingsError::Validation(ref cause) => cause,
DescribeFindingsError::Credentials(ref err) => err.description(),
DescribeFindingsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeFindingsError::ParseError(ref cause) => cause,
DescribeFindingsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeResourceGroupsError {
Internal(String),
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeResourceGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeResourceGroupsError {
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 {
"InternalException" => {
return DescribeResourceGroupsError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return DescribeResourceGroupsError::InvalidInput(String::from(error_message));
}
"ValidationException" => {
return DescribeResourceGroupsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeResourceGroupsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeResourceGroupsError {
fn from(err: serde_json::error::Error) -> DescribeResourceGroupsError {
DescribeResourceGroupsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeResourceGroupsError {
fn from(err: CredentialsError) -> DescribeResourceGroupsError {
DescribeResourceGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeResourceGroupsError {
fn from(err: HttpDispatchError) -> DescribeResourceGroupsError {
DescribeResourceGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeResourceGroupsError {
fn from(err: io::Error) -> DescribeResourceGroupsError {
DescribeResourceGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeResourceGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeResourceGroupsError {
fn description(&self) -> &str {
match *self {
DescribeResourceGroupsError::Internal(ref cause) => cause,
DescribeResourceGroupsError::InvalidInput(ref cause) => cause,
DescribeResourceGroupsError::Validation(ref cause) => cause,
DescribeResourceGroupsError::Credentials(ref err) => err.description(),
DescribeResourceGroupsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeResourceGroupsError::ParseError(ref cause) => cause,
DescribeResourceGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeRulesPackagesError {
Internal(String),
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeRulesPackagesError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeRulesPackagesError {
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 {
"InternalException" => {
return DescribeRulesPackagesError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return DescribeRulesPackagesError::InvalidInput(String::from(error_message));
}
"ValidationException" => {
return DescribeRulesPackagesError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeRulesPackagesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeRulesPackagesError {
fn from(err: serde_json::error::Error) -> DescribeRulesPackagesError {
DescribeRulesPackagesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeRulesPackagesError {
fn from(err: CredentialsError) -> DescribeRulesPackagesError {
DescribeRulesPackagesError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeRulesPackagesError {
fn from(err: HttpDispatchError) -> DescribeRulesPackagesError {
DescribeRulesPackagesError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeRulesPackagesError {
fn from(err: io::Error) -> DescribeRulesPackagesError {
DescribeRulesPackagesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeRulesPackagesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeRulesPackagesError {
fn description(&self) -> &str {
match *self {
DescribeRulesPackagesError::Internal(ref cause) => cause,
DescribeRulesPackagesError::InvalidInput(ref cause) => cause,
DescribeRulesPackagesError::Validation(ref cause) => cause,
DescribeRulesPackagesError::Credentials(ref err) => err.description(),
DescribeRulesPackagesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeRulesPackagesError::ParseError(ref cause) => cause,
DescribeRulesPackagesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetAssessmentReportError {
AccessDenied(String),
AssessmentRunInProgress(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
UnsupportedFeature(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetAssessmentReportError {
pub fn from_response(res: BufferedHttpResponse) -> GetAssessmentReportError {
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 GetAssessmentReportError::AccessDenied(String::from(error_message));
}
"AssessmentRunInProgressException" => {
return GetAssessmentReportError::AssessmentRunInProgress(String::from(
error_message,
));
}
"InternalException" => {
return GetAssessmentReportError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return GetAssessmentReportError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return GetAssessmentReportError::NoSuchEntity(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return GetAssessmentReportError::ServiceTemporarilyUnavailable(String::from(
error_message,
));
}
"UnsupportedFeatureException" => {
return GetAssessmentReportError::UnsupportedFeature(String::from(error_message));
}
"ValidationException" => {
return GetAssessmentReportError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetAssessmentReportError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetAssessmentReportError {
fn from(err: serde_json::error::Error) -> GetAssessmentReportError {
GetAssessmentReportError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetAssessmentReportError {
fn from(err: CredentialsError) -> GetAssessmentReportError {
GetAssessmentReportError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetAssessmentReportError {
fn from(err: HttpDispatchError) -> GetAssessmentReportError {
GetAssessmentReportError::HttpDispatch(err)
}
}
impl From<io::Error> for GetAssessmentReportError {
fn from(err: io::Error) -> GetAssessmentReportError {
GetAssessmentReportError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetAssessmentReportError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetAssessmentReportError {
fn description(&self) -> &str {
match *self {
GetAssessmentReportError::AccessDenied(ref cause) => cause,
GetAssessmentReportError::AssessmentRunInProgress(ref cause) => cause,
GetAssessmentReportError::Internal(ref cause) => cause,
GetAssessmentReportError::InvalidInput(ref cause) => cause,
GetAssessmentReportError::NoSuchEntity(ref cause) => cause,
GetAssessmentReportError::ServiceTemporarilyUnavailable(ref cause) => cause,
GetAssessmentReportError::UnsupportedFeature(ref cause) => cause,
GetAssessmentReportError::Validation(ref cause) => cause,
GetAssessmentReportError::Credentials(ref err) => err.description(),
GetAssessmentReportError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetAssessmentReportError::ParseError(ref cause) => cause,
GetAssessmentReportError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetExclusionsPreviewError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetExclusionsPreviewError {
pub fn from_response(res: BufferedHttpResponse) -> GetExclusionsPreviewError {
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 GetExclusionsPreviewError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return GetExclusionsPreviewError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return GetExclusionsPreviewError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return GetExclusionsPreviewError::NoSuchEntity(String::from(error_message));
}
"ValidationException" => {
return GetExclusionsPreviewError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetExclusionsPreviewError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetExclusionsPreviewError {
fn from(err: serde_json::error::Error) -> GetExclusionsPreviewError {
GetExclusionsPreviewError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetExclusionsPreviewError {
fn from(err: CredentialsError) -> GetExclusionsPreviewError {
GetExclusionsPreviewError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetExclusionsPreviewError {
fn from(err: HttpDispatchError) -> GetExclusionsPreviewError {
GetExclusionsPreviewError::HttpDispatch(err)
}
}
impl From<io::Error> for GetExclusionsPreviewError {
fn from(err: io::Error) -> GetExclusionsPreviewError {
GetExclusionsPreviewError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetExclusionsPreviewError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetExclusionsPreviewError {
fn description(&self) -> &str {
match *self {
GetExclusionsPreviewError::AccessDenied(ref cause) => cause,
GetExclusionsPreviewError::Internal(ref cause) => cause,
GetExclusionsPreviewError::InvalidInput(ref cause) => cause,
GetExclusionsPreviewError::NoSuchEntity(ref cause) => cause,
GetExclusionsPreviewError::Validation(ref cause) => cause,
GetExclusionsPreviewError::Credentials(ref err) => err.description(),
GetExclusionsPreviewError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetExclusionsPreviewError::ParseError(ref cause) => cause,
GetExclusionsPreviewError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum GetTelemetryMetadataError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl GetTelemetryMetadataError {
pub fn from_response(res: BufferedHttpResponse) -> GetTelemetryMetadataError {
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 GetTelemetryMetadataError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return GetTelemetryMetadataError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return GetTelemetryMetadataError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return GetTelemetryMetadataError::NoSuchEntity(String::from(error_message));
}
"ValidationException" => {
return GetTelemetryMetadataError::Validation(error_message.to_string());
}
_ => {}
}
}
return GetTelemetryMetadataError::Unknown(res);
}
}
impl From<serde_json::error::Error> for GetTelemetryMetadataError {
fn from(err: serde_json::error::Error) -> GetTelemetryMetadataError {
GetTelemetryMetadataError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for GetTelemetryMetadataError {
fn from(err: CredentialsError) -> GetTelemetryMetadataError {
GetTelemetryMetadataError::Credentials(err)
}
}
impl From<HttpDispatchError> for GetTelemetryMetadataError {
fn from(err: HttpDispatchError) -> GetTelemetryMetadataError {
GetTelemetryMetadataError::HttpDispatch(err)
}
}
impl From<io::Error> for GetTelemetryMetadataError {
fn from(err: io::Error) -> GetTelemetryMetadataError {
GetTelemetryMetadataError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for GetTelemetryMetadataError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for GetTelemetryMetadataError {
fn description(&self) -> &str {
match *self {
GetTelemetryMetadataError::AccessDenied(ref cause) => cause,
GetTelemetryMetadataError::Internal(ref cause) => cause,
GetTelemetryMetadataError::InvalidInput(ref cause) => cause,
GetTelemetryMetadataError::NoSuchEntity(ref cause) => cause,
GetTelemetryMetadataError::Validation(ref cause) => cause,
GetTelemetryMetadataError::Credentials(ref err) => err.description(),
GetTelemetryMetadataError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
GetTelemetryMetadataError::ParseError(ref cause) => cause,
GetTelemetryMetadataError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListAssessmentRunAgentsError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListAssessmentRunAgentsError {
pub fn from_response(res: BufferedHttpResponse) -> ListAssessmentRunAgentsError {
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 ListAssessmentRunAgentsError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return ListAssessmentRunAgentsError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return ListAssessmentRunAgentsError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return ListAssessmentRunAgentsError::NoSuchEntity(String::from(error_message));
}
"ValidationException" => {
return ListAssessmentRunAgentsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListAssessmentRunAgentsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListAssessmentRunAgentsError {
fn from(err: serde_json::error::Error) -> ListAssessmentRunAgentsError {
ListAssessmentRunAgentsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListAssessmentRunAgentsError {
fn from(err: CredentialsError) -> ListAssessmentRunAgentsError {
ListAssessmentRunAgentsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListAssessmentRunAgentsError {
fn from(err: HttpDispatchError) -> ListAssessmentRunAgentsError {
ListAssessmentRunAgentsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListAssessmentRunAgentsError {
fn from(err: io::Error) -> ListAssessmentRunAgentsError {
ListAssessmentRunAgentsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListAssessmentRunAgentsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListAssessmentRunAgentsError {
fn description(&self) -> &str {
match *self {
ListAssessmentRunAgentsError::AccessDenied(ref cause) => cause,
ListAssessmentRunAgentsError::Internal(ref cause) => cause,
ListAssessmentRunAgentsError::InvalidInput(ref cause) => cause,
ListAssessmentRunAgentsError::NoSuchEntity(ref cause) => cause,
ListAssessmentRunAgentsError::Validation(ref cause) => cause,
ListAssessmentRunAgentsError::Credentials(ref err) => err.description(),
ListAssessmentRunAgentsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListAssessmentRunAgentsError::ParseError(ref cause) => cause,
ListAssessmentRunAgentsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListAssessmentRunsError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListAssessmentRunsError {
pub fn from_response(res: BufferedHttpResponse) -> ListAssessmentRunsError {
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 ListAssessmentRunsError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return ListAssessmentRunsError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return ListAssessmentRunsError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return ListAssessmentRunsError::NoSuchEntity(String::from(error_message));
}
"ValidationException" => {
return ListAssessmentRunsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListAssessmentRunsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListAssessmentRunsError {
fn from(err: serde_json::error::Error) -> ListAssessmentRunsError {
ListAssessmentRunsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListAssessmentRunsError {
fn from(err: CredentialsError) -> ListAssessmentRunsError {
ListAssessmentRunsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListAssessmentRunsError {
fn from(err: HttpDispatchError) -> ListAssessmentRunsError {
ListAssessmentRunsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListAssessmentRunsError {
fn from(err: io::Error) -> ListAssessmentRunsError {
ListAssessmentRunsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListAssessmentRunsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListAssessmentRunsError {
fn description(&self) -> &str {
match *self {
ListAssessmentRunsError::AccessDenied(ref cause) => cause,
ListAssessmentRunsError::Internal(ref cause) => cause,
ListAssessmentRunsError::InvalidInput(ref cause) => cause,
ListAssessmentRunsError::NoSuchEntity(ref cause) => cause,
ListAssessmentRunsError::Validation(ref cause) => cause,
ListAssessmentRunsError::Credentials(ref err) => err.description(),
ListAssessmentRunsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListAssessmentRunsError::ParseError(ref cause) => cause,
ListAssessmentRunsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListAssessmentTargetsError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListAssessmentTargetsError {
pub fn from_response(res: BufferedHttpResponse) -> ListAssessmentTargetsError {
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 ListAssessmentTargetsError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return ListAssessmentTargetsError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return ListAssessmentTargetsError::InvalidInput(String::from(error_message));
}
"ValidationException" => {
return ListAssessmentTargetsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListAssessmentTargetsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListAssessmentTargetsError {
fn from(err: serde_json::error::Error) -> ListAssessmentTargetsError {
ListAssessmentTargetsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListAssessmentTargetsError {
fn from(err: CredentialsError) -> ListAssessmentTargetsError {
ListAssessmentTargetsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListAssessmentTargetsError {
fn from(err: HttpDispatchError) -> ListAssessmentTargetsError {
ListAssessmentTargetsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListAssessmentTargetsError {
fn from(err: io::Error) -> ListAssessmentTargetsError {
ListAssessmentTargetsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListAssessmentTargetsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListAssessmentTargetsError {
fn description(&self) -> &str {
match *self {
ListAssessmentTargetsError::AccessDenied(ref cause) => cause,
ListAssessmentTargetsError::Internal(ref cause) => cause,
ListAssessmentTargetsError::InvalidInput(ref cause) => cause,
ListAssessmentTargetsError::Validation(ref cause) => cause,
ListAssessmentTargetsError::Credentials(ref err) => err.description(),
ListAssessmentTargetsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListAssessmentTargetsError::ParseError(ref cause) => cause,
ListAssessmentTargetsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListAssessmentTemplatesError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListAssessmentTemplatesError {
pub fn from_response(res: BufferedHttpResponse) -> ListAssessmentTemplatesError {
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 ListAssessmentTemplatesError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return ListAssessmentTemplatesError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return ListAssessmentTemplatesError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return ListAssessmentTemplatesError::NoSuchEntity(String::from(error_message));
}
"ValidationException" => {
return ListAssessmentTemplatesError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListAssessmentTemplatesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListAssessmentTemplatesError {
fn from(err: serde_json::error::Error) -> ListAssessmentTemplatesError {
ListAssessmentTemplatesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListAssessmentTemplatesError {
fn from(err: CredentialsError) -> ListAssessmentTemplatesError {
ListAssessmentTemplatesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListAssessmentTemplatesError {
fn from(err: HttpDispatchError) -> ListAssessmentTemplatesError {
ListAssessmentTemplatesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListAssessmentTemplatesError {
fn from(err: io::Error) -> ListAssessmentTemplatesError {
ListAssessmentTemplatesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListAssessmentTemplatesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListAssessmentTemplatesError {
fn description(&self) -> &str {
match *self {
ListAssessmentTemplatesError::AccessDenied(ref cause) => cause,
ListAssessmentTemplatesError::Internal(ref cause) => cause,
ListAssessmentTemplatesError::InvalidInput(ref cause) => cause,
ListAssessmentTemplatesError::NoSuchEntity(ref cause) => cause,
ListAssessmentTemplatesError::Validation(ref cause) => cause,
ListAssessmentTemplatesError::Credentials(ref err) => err.description(),
ListAssessmentTemplatesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListAssessmentTemplatesError::ParseError(ref cause) => cause,
ListAssessmentTemplatesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListEventSubscriptionsError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListEventSubscriptionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListEventSubscriptionsError {
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 ListEventSubscriptionsError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return ListEventSubscriptionsError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return ListEventSubscriptionsError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return ListEventSubscriptionsError::NoSuchEntity(String::from(error_message));
}
"ValidationException" => {
return ListEventSubscriptionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListEventSubscriptionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListEventSubscriptionsError {
fn from(err: serde_json::error::Error) -> ListEventSubscriptionsError {
ListEventSubscriptionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListEventSubscriptionsError {
fn from(err: CredentialsError) -> ListEventSubscriptionsError {
ListEventSubscriptionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListEventSubscriptionsError {
fn from(err: HttpDispatchError) -> ListEventSubscriptionsError {
ListEventSubscriptionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListEventSubscriptionsError {
fn from(err: io::Error) -> ListEventSubscriptionsError {
ListEventSubscriptionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListEventSubscriptionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListEventSubscriptionsError {
fn description(&self) -> &str {
match *self {
ListEventSubscriptionsError::AccessDenied(ref cause) => cause,
ListEventSubscriptionsError::Internal(ref cause) => cause,
ListEventSubscriptionsError::InvalidInput(ref cause) => cause,
ListEventSubscriptionsError::NoSuchEntity(ref cause) => cause,
ListEventSubscriptionsError::Validation(ref cause) => cause,
ListEventSubscriptionsError::Credentials(ref err) => err.description(),
ListEventSubscriptionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListEventSubscriptionsError::ParseError(ref cause) => cause,
ListEventSubscriptionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListExclusionsError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListExclusionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListExclusionsError {
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 ListExclusionsError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return ListExclusionsError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return ListExclusionsError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return ListExclusionsError::NoSuchEntity(String::from(error_message));
}
"ValidationException" => {
return ListExclusionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListExclusionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListExclusionsError {
fn from(err: serde_json::error::Error) -> ListExclusionsError {
ListExclusionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListExclusionsError {
fn from(err: CredentialsError) -> ListExclusionsError {
ListExclusionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListExclusionsError {
fn from(err: HttpDispatchError) -> ListExclusionsError {
ListExclusionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListExclusionsError {
fn from(err: io::Error) -> ListExclusionsError {
ListExclusionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListExclusionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListExclusionsError {
fn description(&self) -> &str {
match *self {
ListExclusionsError::AccessDenied(ref cause) => cause,
ListExclusionsError::Internal(ref cause) => cause,
ListExclusionsError::InvalidInput(ref cause) => cause,
ListExclusionsError::NoSuchEntity(ref cause) => cause,
ListExclusionsError::Validation(ref cause) => cause,
ListExclusionsError::Credentials(ref err) => err.description(),
ListExclusionsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListExclusionsError::ParseError(ref cause) => cause,
ListExclusionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListFindingsError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListFindingsError {
pub fn from_response(res: BufferedHttpResponse) -> ListFindingsError {
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 ListFindingsError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return ListFindingsError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return ListFindingsError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return ListFindingsError::NoSuchEntity(String::from(error_message));
}
"ValidationException" => {
return ListFindingsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListFindingsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListFindingsError {
fn from(err: serde_json::error::Error) -> ListFindingsError {
ListFindingsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListFindingsError {
fn from(err: CredentialsError) -> ListFindingsError {
ListFindingsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListFindingsError {
fn from(err: HttpDispatchError) -> ListFindingsError {
ListFindingsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListFindingsError {
fn from(err: io::Error) -> ListFindingsError {
ListFindingsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListFindingsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListFindingsError {
fn description(&self) -> &str {
match *self {
ListFindingsError::AccessDenied(ref cause) => cause,
ListFindingsError::Internal(ref cause) => cause,
ListFindingsError::InvalidInput(ref cause) => cause,
ListFindingsError::NoSuchEntity(ref cause) => cause,
ListFindingsError::Validation(ref cause) => cause,
ListFindingsError::Credentials(ref err) => err.description(),
ListFindingsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListFindingsError::ParseError(ref cause) => cause,
ListFindingsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListRulesPackagesError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListRulesPackagesError {
pub fn from_response(res: BufferedHttpResponse) -> ListRulesPackagesError {
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 ListRulesPackagesError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return ListRulesPackagesError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return ListRulesPackagesError::InvalidInput(String::from(error_message));
}
"ValidationException" => {
return ListRulesPackagesError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListRulesPackagesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListRulesPackagesError {
fn from(err: serde_json::error::Error) -> ListRulesPackagesError {
ListRulesPackagesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListRulesPackagesError {
fn from(err: CredentialsError) -> ListRulesPackagesError {
ListRulesPackagesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListRulesPackagesError {
fn from(err: HttpDispatchError) -> ListRulesPackagesError {
ListRulesPackagesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListRulesPackagesError {
fn from(err: io::Error) -> ListRulesPackagesError {
ListRulesPackagesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListRulesPackagesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListRulesPackagesError {
fn description(&self) -> &str {
match *self {
ListRulesPackagesError::AccessDenied(ref cause) => cause,
ListRulesPackagesError::Internal(ref cause) => cause,
ListRulesPackagesError::InvalidInput(ref cause) => cause,
ListRulesPackagesError::Validation(ref cause) => cause,
ListRulesPackagesError::Credentials(ref err) => err.description(),
ListRulesPackagesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListRulesPackagesError::ParseError(ref cause) => cause,
ListRulesPackagesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> ListTagsForResourceError {
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 ListTagsForResourceError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return ListTagsForResourceError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return ListTagsForResourceError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return ListTagsForResourceError::NoSuchEntity(String::from(error_message));
}
"ValidationException" => {
return ListTagsForResourceError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListTagsForResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListTagsForResourceError {
fn from(err: serde_json::error::Error) -> ListTagsForResourceError {
ListTagsForResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListTagsForResourceError {
fn from(err: CredentialsError) -> ListTagsForResourceError {
ListTagsForResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListTagsForResourceError {
fn from(err: HttpDispatchError) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for ListTagsForResourceError {
fn from(err: io::Error) -> ListTagsForResourceError {
ListTagsForResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListTagsForResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListTagsForResourceError {
fn description(&self) -> &str {
match *self {
ListTagsForResourceError::AccessDenied(ref cause) => cause,
ListTagsForResourceError::Internal(ref cause) => cause,
ListTagsForResourceError::InvalidInput(ref cause) => cause,
ListTagsForResourceError::NoSuchEntity(ref cause) => cause,
ListTagsForResourceError::Validation(ref cause) => cause,
ListTagsForResourceError::Credentials(ref err) => err.description(),
ListTagsForResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListTagsForResourceError::ParseError(ref cause) => cause,
ListTagsForResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum PreviewAgentsError {
AccessDenied(String),
Internal(String),
InvalidCrossAccountRole(String),
InvalidInput(String),
NoSuchEntity(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PreviewAgentsError {
pub fn from_response(res: BufferedHttpResponse) -> PreviewAgentsError {
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 PreviewAgentsError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return PreviewAgentsError::Internal(String::from(error_message));
}
"InvalidCrossAccountRoleException" => {
return PreviewAgentsError::InvalidCrossAccountRole(String::from(error_message));
}
"InvalidInputException" => {
return PreviewAgentsError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return PreviewAgentsError::NoSuchEntity(String::from(error_message));
}
"ValidationException" => {
return PreviewAgentsError::Validation(error_message.to_string());
}
_ => {}
}
}
return PreviewAgentsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for PreviewAgentsError {
fn from(err: serde_json::error::Error) -> PreviewAgentsError {
PreviewAgentsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for PreviewAgentsError {
fn from(err: CredentialsError) -> PreviewAgentsError {
PreviewAgentsError::Credentials(err)
}
}
impl From<HttpDispatchError> for PreviewAgentsError {
fn from(err: HttpDispatchError) -> PreviewAgentsError {
PreviewAgentsError::HttpDispatch(err)
}
}
impl From<io::Error> for PreviewAgentsError {
fn from(err: io::Error) -> PreviewAgentsError {
PreviewAgentsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PreviewAgentsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PreviewAgentsError {
fn description(&self) -> &str {
match *self {
PreviewAgentsError::AccessDenied(ref cause) => cause,
PreviewAgentsError::Internal(ref cause) => cause,
PreviewAgentsError::InvalidCrossAccountRole(ref cause) => cause,
PreviewAgentsError::InvalidInput(ref cause) => cause,
PreviewAgentsError::NoSuchEntity(ref cause) => cause,
PreviewAgentsError::Validation(ref cause) => cause,
PreviewAgentsError::Credentials(ref err) => err.description(),
PreviewAgentsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
PreviewAgentsError::ParseError(ref cause) => cause,
PreviewAgentsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RegisterCrossAccountAccessRoleError {
AccessDenied(String),
Internal(String),
InvalidCrossAccountRole(String),
InvalidInput(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RegisterCrossAccountAccessRoleError {
pub fn from_response(res: BufferedHttpResponse) -> RegisterCrossAccountAccessRoleError {
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 RegisterCrossAccountAccessRoleError::AccessDenied(String::from(
error_message,
));
}
"InternalException" => {
return RegisterCrossAccountAccessRoleError::Internal(String::from(
error_message,
));
}
"InvalidCrossAccountRoleException" => {
return RegisterCrossAccountAccessRoleError::InvalidCrossAccountRole(
String::from(error_message),
);
}
"InvalidInputException" => {
return RegisterCrossAccountAccessRoleError::InvalidInput(String::from(
error_message,
));
}
"ServiceTemporarilyUnavailableException" => {
return RegisterCrossAccountAccessRoleError::ServiceTemporarilyUnavailable(
String::from(error_message),
);
}
"ValidationException" => {
return RegisterCrossAccountAccessRoleError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return RegisterCrossAccountAccessRoleError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RegisterCrossAccountAccessRoleError {
fn from(err: serde_json::error::Error) -> RegisterCrossAccountAccessRoleError {
RegisterCrossAccountAccessRoleError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RegisterCrossAccountAccessRoleError {
fn from(err: CredentialsError) -> RegisterCrossAccountAccessRoleError {
RegisterCrossAccountAccessRoleError::Credentials(err)
}
}
impl From<HttpDispatchError> for RegisterCrossAccountAccessRoleError {
fn from(err: HttpDispatchError) -> RegisterCrossAccountAccessRoleError {
RegisterCrossAccountAccessRoleError::HttpDispatch(err)
}
}
impl From<io::Error> for RegisterCrossAccountAccessRoleError {
fn from(err: io::Error) -> RegisterCrossAccountAccessRoleError {
RegisterCrossAccountAccessRoleError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RegisterCrossAccountAccessRoleError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RegisterCrossAccountAccessRoleError {
fn description(&self) -> &str {
match *self {
RegisterCrossAccountAccessRoleError::AccessDenied(ref cause) => cause,
RegisterCrossAccountAccessRoleError::Internal(ref cause) => cause,
RegisterCrossAccountAccessRoleError::InvalidCrossAccountRole(ref cause) => cause,
RegisterCrossAccountAccessRoleError::InvalidInput(ref cause) => cause,
RegisterCrossAccountAccessRoleError::ServiceTemporarilyUnavailable(ref cause) => cause,
RegisterCrossAccountAccessRoleError::Validation(ref cause) => cause,
RegisterCrossAccountAccessRoleError::Credentials(ref err) => err.description(),
RegisterCrossAccountAccessRoleError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RegisterCrossAccountAccessRoleError::ParseError(ref cause) => cause,
RegisterCrossAccountAccessRoleError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RemoveAttributesFromFindingsError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RemoveAttributesFromFindingsError {
pub fn from_response(res: BufferedHttpResponse) -> RemoveAttributesFromFindingsError {
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 RemoveAttributesFromFindingsError::AccessDenied(String::from(
error_message,
));
}
"InternalException" => {
return RemoveAttributesFromFindingsError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return RemoveAttributesFromFindingsError::InvalidInput(String::from(
error_message,
));
}
"NoSuchEntityException" => {
return RemoveAttributesFromFindingsError::NoSuchEntity(String::from(
error_message,
));
}
"ServiceTemporarilyUnavailableException" => {
return RemoveAttributesFromFindingsError::ServiceTemporarilyUnavailable(
String::from(error_message),
);
}
"ValidationException" => {
return RemoveAttributesFromFindingsError::Validation(error_message.to_string());
}
_ => {}
}
}
return RemoveAttributesFromFindingsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RemoveAttributesFromFindingsError {
fn from(err: serde_json::error::Error) -> RemoveAttributesFromFindingsError {
RemoveAttributesFromFindingsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RemoveAttributesFromFindingsError {
fn from(err: CredentialsError) -> RemoveAttributesFromFindingsError {
RemoveAttributesFromFindingsError::Credentials(err)
}
}
impl From<HttpDispatchError> for RemoveAttributesFromFindingsError {
fn from(err: HttpDispatchError) -> RemoveAttributesFromFindingsError {
RemoveAttributesFromFindingsError::HttpDispatch(err)
}
}
impl From<io::Error> for RemoveAttributesFromFindingsError {
fn from(err: io::Error) -> RemoveAttributesFromFindingsError {
RemoveAttributesFromFindingsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RemoveAttributesFromFindingsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RemoveAttributesFromFindingsError {
fn description(&self) -> &str {
match *self {
RemoveAttributesFromFindingsError::AccessDenied(ref cause) => cause,
RemoveAttributesFromFindingsError::Internal(ref cause) => cause,
RemoveAttributesFromFindingsError::InvalidInput(ref cause) => cause,
RemoveAttributesFromFindingsError::NoSuchEntity(ref cause) => cause,
RemoveAttributesFromFindingsError::ServiceTemporarilyUnavailable(ref cause) => cause,
RemoveAttributesFromFindingsError::Validation(ref cause) => cause,
RemoveAttributesFromFindingsError::Credentials(ref err) => err.description(),
RemoveAttributesFromFindingsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RemoveAttributesFromFindingsError::ParseError(ref cause) => cause,
RemoveAttributesFromFindingsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum SetTagsForResourceError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl SetTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> SetTagsForResourceError {
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 SetTagsForResourceError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return SetTagsForResourceError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return SetTagsForResourceError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return SetTagsForResourceError::NoSuchEntity(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return SetTagsForResourceError::ServiceTemporarilyUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return SetTagsForResourceError::Validation(error_message.to_string());
}
_ => {}
}
}
return SetTagsForResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for SetTagsForResourceError {
fn from(err: serde_json::error::Error) -> SetTagsForResourceError {
SetTagsForResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for SetTagsForResourceError {
fn from(err: CredentialsError) -> SetTagsForResourceError {
SetTagsForResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for SetTagsForResourceError {
fn from(err: HttpDispatchError) -> SetTagsForResourceError {
SetTagsForResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for SetTagsForResourceError {
fn from(err: io::Error) -> SetTagsForResourceError {
SetTagsForResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for SetTagsForResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for SetTagsForResourceError {
fn description(&self) -> &str {
match *self {
SetTagsForResourceError::AccessDenied(ref cause) => cause,
SetTagsForResourceError::Internal(ref cause) => cause,
SetTagsForResourceError::InvalidInput(ref cause) => cause,
SetTagsForResourceError::NoSuchEntity(ref cause) => cause,
SetTagsForResourceError::ServiceTemporarilyUnavailable(ref cause) => cause,
SetTagsForResourceError::Validation(ref cause) => cause,
SetTagsForResourceError::Credentials(ref err) => err.description(),
SetTagsForResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
SetTagsForResourceError::ParseError(ref cause) => cause,
SetTagsForResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StartAssessmentRunError {
AccessDenied(String),
AgentsAlreadyRunningAssessment(String),
Internal(String),
InvalidCrossAccountRole(String),
InvalidInput(String),
LimitExceeded(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StartAssessmentRunError {
pub fn from_response(res: BufferedHttpResponse) -> StartAssessmentRunError {
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 StartAssessmentRunError::AccessDenied(String::from(error_message));
}
"AgentsAlreadyRunningAssessmentException" => {
return StartAssessmentRunError::AgentsAlreadyRunningAssessment(String::from(
error_message,
));
}
"InternalException" => {
return StartAssessmentRunError::Internal(String::from(error_message));
}
"InvalidCrossAccountRoleException" => {
return StartAssessmentRunError::InvalidCrossAccountRole(String::from(
error_message,
));
}
"InvalidInputException" => {
return StartAssessmentRunError::InvalidInput(String::from(error_message));
}
"LimitExceededException" => {
return StartAssessmentRunError::LimitExceeded(String::from(error_message));
}
"NoSuchEntityException" => {
return StartAssessmentRunError::NoSuchEntity(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return StartAssessmentRunError::ServiceTemporarilyUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return StartAssessmentRunError::Validation(error_message.to_string());
}
_ => {}
}
}
return StartAssessmentRunError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StartAssessmentRunError {
fn from(err: serde_json::error::Error) -> StartAssessmentRunError {
StartAssessmentRunError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StartAssessmentRunError {
fn from(err: CredentialsError) -> StartAssessmentRunError {
StartAssessmentRunError::Credentials(err)
}
}
impl From<HttpDispatchError> for StartAssessmentRunError {
fn from(err: HttpDispatchError) -> StartAssessmentRunError {
StartAssessmentRunError::HttpDispatch(err)
}
}
impl From<io::Error> for StartAssessmentRunError {
fn from(err: io::Error) -> StartAssessmentRunError {
StartAssessmentRunError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StartAssessmentRunError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StartAssessmentRunError {
fn description(&self) -> &str {
match *self {
StartAssessmentRunError::AccessDenied(ref cause) => cause,
StartAssessmentRunError::AgentsAlreadyRunningAssessment(ref cause) => cause,
StartAssessmentRunError::Internal(ref cause) => cause,
StartAssessmentRunError::InvalidCrossAccountRole(ref cause) => cause,
StartAssessmentRunError::InvalidInput(ref cause) => cause,
StartAssessmentRunError::LimitExceeded(ref cause) => cause,
StartAssessmentRunError::NoSuchEntity(ref cause) => cause,
StartAssessmentRunError::ServiceTemporarilyUnavailable(ref cause) => cause,
StartAssessmentRunError::Validation(ref cause) => cause,
StartAssessmentRunError::Credentials(ref err) => err.description(),
StartAssessmentRunError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
StartAssessmentRunError::ParseError(ref cause) => cause,
StartAssessmentRunError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum StopAssessmentRunError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl StopAssessmentRunError {
pub fn from_response(res: BufferedHttpResponse) -> StopAssessmentRunError {
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 StopAssessmentRunError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return StopAssessmentRunError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return StopAssessmentRunError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return StopAssessmentRunError::NoSuchEntity(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return StopAssessmentRunError::ServiceTemporarilyUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return StopAssessmentRunError::Validation(error_message.to_string());
}
_ => {}
}
}
return StopAssessmentRunError::Unknown(res);
}
}
impl From<serde_json::error::Error> for StopAssessmentRunError {
fn from(err: serde_json::error::Error) -> StopAssessmentRunError {
StopAssessmentRunError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for StopAssessmentRunError {
fn from(err: CredentialsError) -> StopAssessmentRunError {
StopAssessmentRunError::Credentials(err)
}
}
impl From<HttpDispatchError> for StopAssessmentRunError {
fn from(err: HttpDispatchError) -> StopAssessmentRunError {
StopAssessmentRunError::HttpDispatch(err)
}
}
impl From<io::Error> for StopAssessmentRunError {
fn from(err: io::Error) -> StopAssessmentRunError {
StopAssessmentRunError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for StopAssessmentRunError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for StopAssessmentRunError {
fn description(&self) -> &str {
match *self {
StopAssessmentRunError::AccessDenied(ref cause) => cause,
StopAssessmentRunError::Internal(ref cause) => cause,
StopAssessmentRunError::InvalidInput(ref cause) => cause,
StopAssessmentRunError::NoSuchEntity(ref cause) => cause,
StopAssessmentRunError::ServiceTemporarilyUnavailable(ref cause) => cause,
StopAssessmentRunError::Validation(ref cause) => cause,
StopAssessmentRunError::Credentials(ref err) => err.description(),
StopAssessmentRunError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
StopAssessmentRunError::ParseError(ref cause) => cause,
StopAssessmentRunError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum SubscribeToEventError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
LimitExceeded(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl SubscribeToEventError {
pub fn from_response(res: BufferedHttpResponse) -> SubscribeToEventError {
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 SubscribeToEventError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return SubscribeToEventError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return SubscribeToEventError::InvalidInput(String::from(error_message));
}
"LimitExceededException" => {
return SubscribeToEventError::LimitExceeded(String::from(error_message));
}
"NoSuchEntityException" => {
return SubscribeToEventError::NoSuchEntity(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return SubscribeToEventError::ServiceTemporarilyUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return SubscribeToEventError::Validation(error_message.to_string());
}
_ => {}
}
}
return SubscribeToEventError::Unknown(res);
}
}
impl From<serde_json::error::Error> for SubscribeToEventError {
fn from(err: serde_json::error::Error) -> SubscribeToEventError {
SubscribeToEventError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for SubscribeToEventError {
fn from(err: CredentialsError) -> SubscribeToEventError {
SubscribeToEventError::Credentials(err)
}
}
impl From<HttpDispatchError> for SubscribeToEventError {
fn from(err: HttpDispatchError) -> SubscribeToEventError {
SubscribeToEventError::HttpDispatch(err)
}
}
impl From<io::Error> for SubscribeToEventError {
fn from(err: io::Error) -> SubscribeToEventError {
SubscribeToEventError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for SubscribeToEventError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for SubscribeToEventError {
fn description(&self) -> &str {
match *self {
SubscribeToEventError::AccessDenied(ref cause) => cause,
SubscribeToEventError::Internal(ref cause) => cause,
SubscribeToEventError::InvalidInput(ref cause) => cause,
SubscribeToEventError::LimitExceeded(ref cause) => cause,
SubscribeToEventError::NoSuchEntity(ref cause) => cause,
SubscribeToEventError::ServiceTemporarilyUnavailable(ref cause) => cause,
SubscribeToEventError::Validation(ref cause) => cause,
SubscribeToEventError::Credentials(ref err) => err.description(),
SubscribeToEventError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
SubscribeToEventError::ParseError(ref cause) => cause,
SubscribeToEventError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UnsubscribeFromEventError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UnsubscribeFromEventError {
pub fn from_response(res: BufferedHttpResponse) -> UnsubscribeFromEventError {
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 UnsubscribeFromEventError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return UnsubscribeFromEventError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return UnsubscribeFromEventError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return UnsubscribeFromEventError::NoSuchEntity(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return UnsubscribeFromEventError::ServiceTemporarilyUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return UnsubscribeFromEventError::Validation(error_message.to_string());
}
_ => {}
}
}
return UnsubscribeFromEventError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UnsubscribeFromEventError {
fn from(err: serde_json::error::Error) -> UnsubscribeFromEventError {
UnsubscribeFromEventError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UnsubscribeFromEventError {
fn from(err: CredentialsError) -> UnsubscribeFromEventError {
UnsubscribeFromEventError::Credentials(err)
}
}
impl From<HttpDispatchError> for UnsubscribeFromEventError {
fn from(err: HttpDispatchError) -> UnsubscribeFromEventError {
UnsubscribeFromEventError::HttpDispatch(err)
}
}
impl From<io::Error> for UnsubscribeFromEventError {
fn from(err: io::Error) -> UnsubscribeFromEventError {
UnsubscribeFromEventError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UnsubscribeFromEventError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UnsubscribeFromEventError {
fn description(&self) -> &str {
match *self {
UnsubscribeFromEventError::AccessDenied(ref cause) => cause,
UnsubscribeFromEventError::Internal(ref cause) => cause,
UnsubscribeFromEventError::InvalidInput(ref cause) => cause,
UnsubscribeFromEventError::NoSuchEntity(ref cause) => cause,
UnsubscribeFromEventError::ServiceTemporarilyUnavailable(ref cause) => cause,
UnsubscribeFromEventError::Validation(ref cause) => cause,
UnsubscribeFromEventError::Credentials(ref err) => err.description(),
UnsubscribeFromEventError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UnsubscribeFromEventError::ParseError(ref cause) => cause,
UnsubscribeFromEventError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateAssessmentTargetError {
AccessDenied(String),
Internal(String),
InvalidInput(String),
NoSuchEntity(String),
ServiceTemporarilyUnavailable(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateAssessmentTargetError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateAssessmentTargetError {
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 UpdateAssessmentTargetError::AccessDenied(String::from(error_message));
}
"InternalException" => {
return UpdateAssessmentTargetError::Internal(String::from(error_message));
}
"InvalidInputException" => {
return UpdateAssessmentTargetError::InvalidInput(String::from(error_message));
}
"NoSuchEntityException" => {
return UpdateAssessmentTargetError::NoSuchEntity(String::from(error_message));
}
"ServiceTemporarilyUnavailableException" => {
return UpdateAssessmentTargetError::ServiceTemporarilyUnavailable(String::from(
error_message,
));
}
"ValidationException" => {
return UpdateAssessmentTargetError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateAssessmentTargetError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateAssessmentTargetError {
fn from(err: serde_json::error::Error) -> UpdateAssessmentTargetError {
UpdateAssessmentTargetError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateAssessmentTargetError {
fn from(err: CredentialsError) -> UpdateAssessmentTargetError {
UpdateAssessmentTargetError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateAssessmentTargetError {
fn from(err: HttpDispatchError) -> UpdateAssessmentTargetError {
UpdateAssessmentTargetError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateAssessmentTargetError {
fn from(err: io::Error) -> UpdateAssessmentTargetError {
UpdateAssessmentTargetError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateAssessmentTargetError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateAssessmentTargetError {
fn description(&self) -> &str {
match *self {
UpdateAssessmentTargetError::AccessDenied(ref cause) => cause,
UpdateAssessmentTargetError::Internal(ref cause) => cause,
UpdateAssessmentTargetError::InvalidInput(ref cause) => cause,
UpdateAssessmentTargetError::NoSuchEntity(ref cause) => cause,
UpdateAssessmentTargetError::ServiceTemporarilyUnavailable(ref cause) => cause,
UpdateAssessmentTargetError::Validation(ref cause) => cause,
UpdateAssessmentTargetError::Credentials(ref err) => err.description(),
UpdateAssessmentTargetError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdateAssessmentTargetError::ParseError(ref cause) => cause,
UpdateAssessmentTargetError::Unknown(_) => "unknown error",
}
}
}
pub trait Inspector {
fn add_attributes_to_findings(
&self,
input: AddAttributesToFindingsRequest,
) -> RusotoFuture<AddAttributesToFindingsResponse, AddAttributesToFindingsError>;
fn create_assessment_target(
&self,
input: CreateAssessmentTargetRequest,
) -> RusotoFuture<CreateAssessmentTargetResponse, CreateAssessmentTargetError>;
fn create_assessment_template(
&self,
input: CreateAssessmentTemplateRequest,
) -> RusotoFuture<CreateAssessmentTemplateResponse, CreateAssessmentTemplateError>;
fn create_exclusions_preview(
&self,
input: CreateExclusionsPreviewRequest,
) -> RusotoFuture<CreateExclusionsPreviewResponse, CreateExclusionsPreviewError>;
fn create_resource_group(
&self,
input: CreateResourceGroupRequest,
) -> RusotoFuture<CreateResourceGroupResponse, CreateResourceGroupError>;
fn delete_assessment_run(
&self,
input: DeleteAssessmentRunRequest,
) -> RusotoFuture<(), DeleteAssessmentRunError>;
fn delete_assessment_target(
&self,
input: DeleteAssessmentTargetRequest,
) -> RusotoFuture<(), DeleteAssessmentTargetError>;
fn delete_assessment_template(
&self,
input: DeleteAssessmentTemplateRequest,
) -> RusotoFuture<(), DeleteAssessmentTemplateError>;
fn describe_assessment_runs(
&self,
input: DescribeAssessmentRunsRequest,
) -> RusotoFuture<DescribeAssessmentRunsResponse, DescribeAssessmentRunsError>;
fn describe_assessment_targets(
&self,
input: DescribeAssessmentTargetsRequest,
) -> RusotoFuture<DescribeAssessmentTargetsResponse, DescribeAssessmentTargetsError>;
fn describe_assessment_templates(
&self,
input: DescribeAssessmentTemplatesRequest,
) -> RusotoFuture<DescribeAssessmentTemplatesResponse, DescribeAssessmentTemplatesError>;
fn describe_cross_account_access_role(
&self,
) -> RusotoFuture<DescribeCrossAccountAccessRoleResponse, DescribeCrossAccountAccessRoleError>;
fn describe_exclusions(
&self,
input: DescribeExclusionsRequest,
) -> RusotoFuture<DescribeExclusionsResponse, DescribeExclusionsError>;
fn describe_findings(
&self,
input: DescribeFindingsRequest,
) -> RusotoFuture<DescribeFindingsResponse, DescribeFindingsError>;
fn describe_resource_groups(
&self,
input: DescribeResourceGroupsRequest,
) -> RusotoFuture<DescribeResourceGroupsResponse, DescribeResourceGroupsError>;
fn describe_rules_packages(
&self,
input: DescribeRulesPackagesRequest,
) -> RusotoFuture<DescribeRulesPackagesResponse, DescribeRulesPackagesError>;
fn get_assessment_report(
&self,
input: GetAssessmentReportRequest,
) -> RusotoFuture<GetAssessmentReportResponse, GetAssessmentReportError>;
fn get_exclusions_preview(
&self,
input: GetExclusionsPreviewRequest,
) -> RusotoFuture<GetExclusionsPreviewResponse, GetExclusionsPreviewError>;
fn get_telemetry_metadata(
&self,
input: GetTelemetryMetadataRequest,
) -> RusotoFuture<GetTelemetryMetadataResponse, GetTelemetryMetadataError>;
fn list_assessment_run_agents(
&self,
input: ListAssessmentRunAgentsRequest,
) -> RusotoFuture<ListAssessmentRunAgentsResponse, ListAssessmentRunAgentsError>;
fn list_assessment_runs(
&self,
input: ListAssessmentRunsRequest,
) -> RusotoFuture<ListAssessmentRunsResponse, ListAssessmentRunsError>;
fn list_assessment_targets(
&self,
input: ListAssessmentTargetsRequest,
) -> RusotoFuture<ListAssessmentTargetsResponse, ListAssessmentTargetsError>;
fn list_assessment_templates(
&self,
input: ListAssessmentTemplatesRequest,
) -> RusotoFuture<ListAssessmentTemplatesResponse, ListAssessmentTemplatesError>;
fn list_event_subscriptions(
&self,
input: ListEventSubscriptionsRequest,
) -> RusotoFuture<ListEventSubscriptionsResponse, ListEventSubscriptionsError>;
fn list_exclusions(
&self,
input: ListExclusionsRequest,
) -> RusotoFuture<ListExclusionsResponse, ListExclusionsError>;
fn list_findings(
&self,
input: ListFindingsRequest,
) -> RusotoFuture<ListFindingsResponse, ListFindingsError>;
fn list_rules_packages(
&self,
input: ListRulesPackagesRequest,
) -> RusotoFuture<ListRulesPackagesResponse, ListRulesPackagesError>;
fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> RusotoFuture<ListTagsForResourceResponse, ListTagsForResourceError>;
fn preview_agents(
&self,
input: PreviewAgentsRequest,
) -> RusotoFuture<PreviewAgentsResponse, PreviewAgentsError>;
fn register_cross_account_access_role(
&self,
input: RegisterCrossAccountAccessRoleRequest,
) -> RusotoFuture<(), RegisterCrossAccountAccessRoleError>;
fn remove_attributes_from_findings(
&self,
input: RemoveAttributesFromFindingsRequest,
) -> RusotoFuture<RemoveAttributesFromFindingsResponse, RemoveAttributesFromFindingsError>;
fn set_tags_for_resource(
&self,
input: SetTagsForResourceRequest,
) -> RusotoFuture<(), SetTagsForResourceError>;
fn start_assessment_run(
&self,
input: StartAssessmentRunRequest,
) -> RusotoFuture<StartAssessmentRunResponse, StartAssessmentRunError>;
fn stop_assessment_run(
&self,
input: StopAssessmentRunRequest,
) -> RusotoFuture<(), StopAssessmentRunError>;
fn subscribe_to_event(
&self,
input: SubscribeToEventRequest,
) -> RusotoFuture<(), SubscribeToEventError>;
fn unsubscribe_from_event(
&self,
input: UnsubscribeFromEventRequest,
) -> RusotoFuture<(), UnsubscribeFromEventError>;
fn update_assessment_target(
&self,
input: UpdateAssessmentTargetRequest,
) -> RusotoFuture<(), UpdateAssessmentTargetError>;
}
#[derive(Clone)]
pub struct InspectorClient {
client: Client,
region: region::Region,
}
impl InspectorClient {
pub fn new(region: region::Region) -> InspectorClient {
InspectorClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> InspectorClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
InspectorClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl Inspector for InspectorClient {
fn add_attributes_to_findings(
&self,
input: AddAttributesToFindingsRequest,
) -> RusotoFuture<AddAttributesToFindingsResponse, AddAttributesToFindingsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.AddAttributesToFindings");
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::<AddAttributesToFindingsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(AddAttributesToFindingsError::from_response(response))
}))
}
})
}
fn create_assessment_target(
&self,
input: CreateAssessmentTargetRequest,
) -> RusotoFuture<CreateAssessmentTargetResponse, CreateAssessmentTargetError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.CreateAssessmentTarget");
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::<CreateAssessmentTargetResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateAssessmentTargetError::from_response(response))
}),
)
}
})
}
fn create_assessment_template(
&self,
input: CreateAssessmentTemplateRequest,
) -> RusotoFuture<CreateAssessmentTemplateResponse, CreateAssessmentTemplateError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.CreateAssessmentTemplate");
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::<CreateAssessmentTemplateResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateAssessmentTemplateError::from_response(response))
}))
}
})
}
fn create_exclusions_preview(
&self,
input: CreateExclusionsPreviewRequest,
) -> RusotoFuture<CreateExclusionsPreviewResponse, CreateExclusionsPreviewError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.CreateExclusionsPreview");
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::<CreateExclusionsPreviewResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(CreateExclusionsPreviewError::from_response(response))
}))
}
})
}
fn create_resource_group(
&self,
input: CreateResourceGroupRequest,
) -> RusotoFuture<CreateResourceGroupResponse, CreateResourceGroupError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.CreateResourceGroup");
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::<CreateResourceGroupResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(CreateResourceGroupError::from_response(response))
}),
)
}
})
}
fn delete_assessment_run(
&self,
input: DeleteAssessmentRunRequest,
) -> RusotoFuture<(), DeleteAssessmentRunError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.DeleteAssessmentRun");
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(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteAssessmentRunError::from_response(response))
}),
)
}
})
}
fn delete_assessment_target(
&self,
input: DeleteAssessmentTargetRequest,
) -> RusotoFuture<(), DeleteAssessmentTargetError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.DeleteAssessmentTarget");
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(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeleteAssessmentTargetError::from_response(response))
}),
)
}
})
}
fn delete_assessment_template(
&self,
input: DeleteAssessmentTemplateRequest,
) -> RusotoFuture<(), DeleteAssessmentTemplateError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.DeleteAssessmentTemplate");
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(future::ok(::std::mem::drop(response)))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteAssessmentTemplateError::from_response(response))
}))
}
})
}
fn describe_assessment_runs(
&self,
input: DescribeAssessmentRunsRequest,
) -> RusotoFuture<DescribeAssessmentRunsResponse, DescribeAssessmentRunsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.DescribeAssessmentRuns");
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::<DescribeAssessmentRunsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeAssessmentRunsError::from_response(response))
}),
)
}
})
}
fn describe_assessment_targets(
&self,
input: DescribeAssessmentTargetsRequest,
) -> RusotoFuture<DescribeAssessmentTargetsResponse, DescribeAssessmentTargetsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.DescribeAssessmentTargets");
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::<DescribeAssessmentTargetsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeAssessmentTargetsError::from_response(response))
}))
}
})
}
fn describe_assessment_templates(
&self,
input: DescribeAssessmentTemplatesRequest,
) -> RusotoFuture<DescribeAssessmentTemplatesResponse, DescribeAssessmentTemplatesError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"InspectorService.DescribeAssessmentTemplates",
);
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::<DescribeAssessmentTemplatesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeAssessmentTemplatesError::from_response(response))
}))
}
})
}
fn describe_cross_account_access_role(
&self,
) -> RusotoFuture<DescribeCrossAccountAccessRoleResponse, DescribeCrossAccountAccessRoleError>
{
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"InspectorService.DescribeCrossAccountAccessRole",
);
request.set_payload(Some(b"{}".to_vec()));
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::<DescribeCrossAccountAccessRoleResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DescribeCrossAccountAccessRoleError::from_response(response))
}))
}
})
}
fn describe_exclusions(
&self,
input: DescribeExclusionsRequest,
) -> RusotoFuture<DescribeExclusionsResponse, DescribeExclusionsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.DescribeExclusions");
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::<DescribeExclusionsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeExclusionsError::from_response(response))),
)
}
})
}
fn describe_findings(
&self,
input: DescribeFindingsRequest,
) -> RusotoFuture<DescribeFindingsResponse, DescribeFindingsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.DescribeFindings");
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::<DescribeFindingsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeFindingsError::from_response(response))),
)
}
})
}
fn describe_resource_groups(
&self,
input: DescribeResourceGroupsRequest,
) -> RusotoFuture<DescribeResourceGroupsResponse, DescribeResourceGroupsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.DescribeResourceGroups");
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::<DescribeResourceGroupsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeResourceGroupsError::from_response(response))
}),
)
}
})
}
fn describe_rules_packages(
&self,
input: DescribeRulesPackagesRequest,
) -> RusotoFuture<DescribeRulesPackagesResponse, DescribeRulesPackagesError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.DescribeRulesPackages");
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::<DescribeRulesPackagesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeRulesPackagesError::from_response(response))
}),
)
}
})
}
fn get_assessment_report(
&self,
input: GetAssessmentReportRequest,
) -> RusotoFuture<GetAssessmentReportResponse, GetAssessmentReportError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.GetAssessmentReport");
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::<GetAssessmentReportResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetAssessmentReportError::from_response(response))
}),
)
}
})
}
fn get_exclusions_preview(
&self,
input: GetExclusionsPreviewRequest,
) -> RusotoFuture<GetExclusionsPreviewResponse, GetExclusionsPreviewError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.GetExclusionsPreview");
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::<GetExclusionsPreviewResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetExclusionsPreviewError::from_response(response))
}),
)
}
})
}
fn get_telemetry_metadata(
&self,
input: GetTelemetryMetadataRequest,
) -> RusotoFuture<GetTelemetryMetadataResponse, GetTelemetryMetadataError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.GetTelemetryMetadata");
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::<GetTelemetryMetadataResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(GetTelemetryMetadataError::from_response(response))
}),
)
}
})
}
fn list_assessment_run_agents(
&self,
input: ListAssessmentRunAgentsRequest,
) -> RusotoFuture<ListAssessmentRunAgentsResponse, ListAssessmentRunAgentsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.ListAssessmentRunAgents");
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::<ListAssessmentRunAgentsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListAssessmentRunAgentsError::from_response(response))
}))
}
})
}
fn list_assessment_runs(
&self,
input: ListAssessmentRunsRequest,
) -> RusotoFuture<ListAssessmentRunsResponse, ListAssessmentRunsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.ListAssessmentRuns");
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::<ListAssessmentRunsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListAssessmentRunsError::from_response(response))),
)
}
})
}
fn list_assessment_targets(
&self,
input: ListAssessmentTargetsRequest,
) -> RusotoFuture<ListAssessmentTargetsResponse, ListAssessmentTargetsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.ListAssessmentTargets");
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::<ListAssessmentTargetsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListAssessmentTargetsError::from_response(response))
}),
)
}
})
}
fn list_assessment_templates(
&self,
input: ListAssessmentTemplatesRequest,
) -> RusotoFuture<ListAssessmentTemplatesResponse, ListAssessmentTemplatesError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.ListAssessmentTemplates");
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::<ListAssessmentTemplatesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(ListAssessmentTemplatesError::from_response(response))
}))
}
})
}
fn list_event_subscriptions(
&self,
input: ListEventSubscriptionsRequest,
) -> RusotoFuture<ListEventSubscriptionsResponse, ListEventSubscriptionsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.ListEventSubscriptions");
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::<ListEventSubscriptionsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListEventSubscriptionsError::from_response(response))
}),
)
}
})
}
fn list_exclusions(
&self,
input: ListExclusionsRequest,
) -> RusotoFuture<ListExclusionsResponse, ListExclusionsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.ListExclusions");
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::<ListExclusionsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListExclusionsError::from_response(response))),
)
}
})
}
fn list_findings(
&self,
input: ListFindingsRequest,
) -> RusotoFuture<ListFindingsResponse, ListFindingsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.ListFindings");
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::<ListFindingsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListFindingsError::from_response(response))),
)
}
})
}
fn list_rules_packages(
&self,
input: ListRulesPackagesRequest,
) -> RusotoFuture<ListRulesPackagesResponse, ListRulesPackagesError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.ListRulesPackages");
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::<ListRulesPackagesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListRulesPackagesError::from_response(response))),
)
}
})
}
fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> RusotoFuture<ListTagsForResourceResponse, ListTagsForResourceError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.ListTagsForResource");
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::<ListTagsForResourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListTagsForResourceError::from_response(response))
}),
)
}
})
}
fn preview_agents(
&self,
input: PreviewAgentsRequest,
) -> RusotoFuture<PreviewAgentsResponse, PreviewAgentsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.PreviewAgents");
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::<PreviewAgentsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(PreviewAgentsError::from_response(response))),
)
}
})
}
fn register_cross_account_access_role(
&self,
input: RegisterCrossAccountAccessRoleRequest,
) -> RusotoFuture<(), RegisterCrossAccountAccessRoleError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"InspectorService.RegisterCrossAccountAccessRole",
);
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(future::ok(::std::mem::drop(response)))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(RegisterCrossAccountAccessRoleError::from_response(response))
}))
}
})
}
fn remove_attributes_from_findings(
&self,
input: RemoveAttributesFromFindingsRequest,
) -> RusotoFuture<RemoveAttributesFromFindingsResponse, RemoveAttributesFromFindingsError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"InspectorService.RemoveAttributesFromFindings",
);
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::<RemoveAttributesFromFindingsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(RemoveAttributesFromFindingsError::from_response(response))
}))
}
})
}
fn set_tags_for_resource(
&self,
input: SetTagsForResourceRequest,
) -> RusotoFuture<(), SetTagsForResourceError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.SetTagsForResource");
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(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(SetTagsForResourceError::from_response(response))),
)
}
})
}
fn start_assessment_run(
&self,
input: StartAssessmentRunRequest,
) -> RusotoFuture<StartAssessmentRunResponse, StartAssessmentRunError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.StartAssessmentRun");
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::<StartAssessmentRunResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StartAssessmentRunError::from_response(response))),
)
}
})
}
fn stop_assessment_run(
&self,
input: StopAssessmentRunRequest,
) -> RusotoFuture<(), StopAssessmentRunError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.StopAssessmentRun");
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(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(StopAssessmentRunError::from_response(response))),
)
}
})
}
fn subscribe_to_event(
&self,
input: SubscribeToEventRequest,
) -> RusotoFuture<(), SubscribeToEventError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.SubscribeToEvent");
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(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(SubscribeToEventError::from_response(response))),
)
}
})
}
fn unsubscribe_from_event(
&self,
input: UnsubscribeFromEventRequest,
) -> RusotoFuture<(), UnsubscribeFromEventError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.UnsubscribeFromEvent");
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(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(UnsubscribeFromEventError::from_response(response))
}),
)
}
})
}
fn update_assessment_target(
&self,
input: UpdateAssessmentTargetRequest,
) -> RusotoFuture<(), UpdateAssessmentTargetError> {
let mut request = SignedRequest::new("POST", "inspector", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "InspectorService.UpdateAssessmentTarget");
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(future::ok(::std::mem::drop(response)))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(UpdateAssessmentTargetError::from_response(response))
}),
)
}
})
}
}
#[cfg(test)]
mod protocol_tests {}