use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl DiscoveryClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "discovery", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AgentConfigurationStatus {
#[serde(rename = "agentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_id: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "operationSucceeded")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_succeeded: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AgentInfo {
#[serde(rename = "agentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_id: Option<String>,
#[serde(rename = "agentNetworkInfoList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_network_info_list: Option<Vec<AgentNetworkInfo>>,
#[serde(rename = "agentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_type: Option<String>,
#[serde(rename = "collectionStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub collection_status: Option<String>,
#[serde(rename = "connectorId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_id: Option<String>,
#[serde(rename = "health")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health: Option<String>,
#[serde(rename = "hostName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub host_name: Option<String>,
#[serde(rename = "lastHealthPingTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_health_ping_time: Option<String>,
#[serde(rename = "registeredTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registered_time: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AgentNetworkInfo {
#[serde(rename = "ipAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address: Option<String>,
#[serde(rename = "macAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mac_address: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateConfigurationItemsToApplicationRequest {
#[serde(rename = "applicationConfigurationId")]
pub application_configuration_id: String,
#[serde(rename = "configurationIds")]
pub configuration_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateConfigurationItemsToApplicationResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DiscoveryBatchDeleteImportDataError {
#[serde(rename = "errorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "errorDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_description: Option<String>,
#[serde(rename = "importTaskId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_task_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchDeleteImportDataRequest {
#[serde(rename = "importTaskIds")]
pub import_task_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchDeleteImportDataResponse {
#[serde(rename = "errors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub errors: Option<Vec<DiscoveryBatchDeleteImportDataError>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfigurationTag {
#[serde(rename = "configurationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_id: Option<String>,
#[serde(rename = "configurationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_type: Option<String>,
#[serde(rename = "key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "timeOfCreation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub time_of_creation: Option<f64>,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContinuousExportDescription {
#[serde(rename = "dataSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source: Option<String>,
#[serde(rename = "exportId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub export_id: Option<String>,
#[serde(rename = "s3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_bucket: Option<String>,
#[serde(rename = "schemaStorageConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_storage_config: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "statusDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_detail: Option<String>,
#[serde(rename = "stopTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stop_time: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateApplicationRequest {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateApplicationResponse {
#[serde(rename = "configurationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTagsRequest {
#[serde(rename = "configurationIds")]
pub configuration_ids: Vec<String>,
#[serde(rename = "tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTagsResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CustomerAgentInfo {
#[serde(rename = "activeAgents")]
pub active_agents: i64,
#[serde(rename = "blackListedAgents")]
pub black_listed_agents: i64,
#[serde(rename = "healthyAgents")]
pub healthy_agents: i64,
#[serde(rename = "shutdownAgents")]
pub shutdown_agents: i64,
#[serde(rename = "totalAgents")]
pub total_agents: i64,
#[serde(rename = "unhealthyAgents")]
pub unhealthy_agents: i64,
#[serde(rename = "unknownAgents")]
pub unknown_agents: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CustomerConnectorInfo {
#[serde(rename = "activeConnectors")]
pub active_connectors: i64,
#[serde(rename = "blackListedConnectors")]
pub black_listed_connectors: i64,
#[serde(rename = "healthyConnectors")]
pub healthy_connectors: i64,
#[serde(rename = "shutdownConnectors")]
pub shutdown_connectors: i64,
#[serde(rename = "totalConnectors")]
pub total_connectors: i64,
#[serde(rename = "unhealthyConnectors")]
pub unhealthy_connectors: i64,
#[serde(rename = "unknownConnectors")]
pub unknown_connectors: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApplicationsRequest {
#[serde(rename = "configurationIds")]
pub configuration_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteApplicationsResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTagsRequest {
#[serde(rename = "configurationIds")]
pub configuration_ids: Vec<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTagsResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAgentsRequest {
#[serde(rename = "agentIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_ids: Option<Vec<String>>,
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAgentsResponse {
#[serde(rename = "agentsInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agents_info: Option<Vec<AgentInfo>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeConfigurationsRequest {
#[serde(rename = "configurationIds")]
pub configuration_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeConfigurationsResponse {
#[serde(rename = "configurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configurations: Option<Vec<::std::collections::HashMap<String, String>>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeContinuousExportsRequest {
#[serde(rename = "exportIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub export_ids: Option<Vec<String>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeContinuousExportsResponse {
#[serde(rename = "descriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub descriptions: Option<Vec<ContinuousExportDescription>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeExportConfigurationsRequest {
#[serde(rename = "exportIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub export_ids: Option<Vec<String>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeExportConfigurationsResponse {
#[serde(rename = "exportsInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exports_info: Option<Vec<ExportInfo>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeExportTasksRequest {
#[serde(rename = "exportIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub export_ids: Option<Vec<String>>,
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<ExportFilter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeExportTasksResponse {
#[serde(rename = "exportsInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exports_info: Option<Vec<ExportInfo>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeImportTasksRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<ImportTaskFilter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeImportTasksResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "tasks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tasks: Option<Vec<ImportTask>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTagsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<TagFilter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTagsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<ConfigurationTag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateConfigurationItemsFromApplicationRequest {
#[serde(rename = "applicationConfigurationId")]
pub application_configuration_id: String,
#[serde(rename = "configurationIds")]
pub configuration_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateConfigurationItemsFromApplicationResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExportConfigurationsResponse {
#[serde(rename = "exportId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub export_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ExportFilter {
#[serde(rename = "condition")]
pub condition: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "values")]
pub values: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExportInfo {
#[serde(rename = "configurationsDownloadUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configurations_download_url: Option<String>,
#[serde(rename = "exportId")]
pub export_id: String,
#[serde(rename = "exportRequestTime")]
pub export_request_time: f64,
#[serde(rename = "exportStatus")]
pub export_status: String,
#[serde(rename = "isTruncated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_truncated: Option<bool>,
#[serde(rename = "requestedEndTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_end_time: Option<f64>,
#[serde(rename = "requestedStartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_start_time: Option<f64>,
#[serde(rename = "statusMessage")]
pub status_message: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Filter {
#[serde(rename = "condition")]
pub condition: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "values")]
pub values: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDiscoverySummaryRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDiscoverySummaryResponse {
#[serde(rename = "agentSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_summary: Option<CustomerAgentInfo>,
#[serde(rename = "applications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub applications: Option<i64>,
#[serde(rename = "connectorSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_summary: Option<CustomerConnectorInfo>,
#[serde(rename = "servers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub servers: Option<i64>,
#[serde(rename = "serversMappedToApplications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub servers_mapped_to_applications: Option<i64>,
#[serde(rename = "serversMappedtoTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub servers_mappedto_tags: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImportTask {
#[serde(rename = "applicationImportFailure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_import_failure: Option<i64>,
#[serde(rename = "applicationImportSuccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_import_success: Option<i64>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "errorsAndFailedEntriesZip")]
#[serde(skip_serializing_if = "Option::is_none")]
pub errors_and_failed_entries_zip: Option<String>,
#[serde(rename = "importCompletionTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_completion_time: Option<f64>,
#[serde(rename = "importDeletedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_deleted_time: Option<f64>,
#[serde(rename = "importRequestTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_request_time: Option<f64>,
#[serde(rename = "importTaskId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_task_id: Option<String>,
#[serde(rename = "importUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_url: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "serverImportFailure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_import_failure: Option<i64>,
#[serde(rename = "serverImportSuccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_import_success: Option<i64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ImportTaskFilter {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListConfigurationsRequest {
#[serde(rename = "configurationType")]
pub configuration_type: String,
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[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 = "orderBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub order_by: Option<Vec<OrderByElement>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListConfigurationsResponse {
#[serde(rename = "configurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configurations: Option<Vec<::std::collections::HashMap<String, String>>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListServerNeighborsRequest {
#[serde(rename = "configurationId")]
pub configuration_id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "neighborConfigurationIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub neighbor_configuration_ids: Option<Vec<String>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "portInformationNeeded")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_information_needed: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListServerNeighborsResponse {
#[serde(rename = "knownDependencyCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub known_dependency_count: Option<i64>,
#[serde(rename = "neighbors")]
pub neighbors: Vec<NeighborConnectionDetail>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NeighborConnectionDetail {
#[serde(rename = "connectionsCount")]
pub connections_count: i64,
#[serde(rename = "destinationPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_port: Option<i64>,
#[serde(rename = "destinationServerId")]
pub destination_server_id: String,
#[serde(rename = "sourceServerId")]
pub source_server_id: String,
#[serde(rename = "transportProtocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transport_protocol: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OrderByElement {
#[serde(rename = "fieldName")]
pub field_name: String,
#[serde(rename = "sortOrder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sort_order: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartContinuousExportRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartContinuousExportResponse {
#[serde(rename = "dataSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source: Option<String>,
#[serde(rename = "exportId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub export_id: Option<String>,
#[serde(rename = "s3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_bucket: Option<String>,
#[serde(rename = "schemaStorageConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_storage_config: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartDataCollectionByAgentIdsRequest {
#[serde(rename = "agentIds")]
pub agent_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartDataCollectionByAgentIdsResponse {
#[serde(rename = "agentsConfigurationStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agents_configuration_status: Option<Vec<AgentConfigurationStatus>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartExportTaskRequest {
#[serde(rename = "endTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "exportDataFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub export_data_format: Option<Vec<String>>,
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<ExportFilter>>,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartExportTaskResponse {
#[serde(rename = "exportId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub export_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartImportTaskRequest {
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "importUrl")]
pub import_url: String,
#[serde(rename = "name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartImportTaskResponse {
#[serde(rename = "task")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task: Option<ImportTask>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopContinuousExportRequest {
#[serde(rename = "exportId")]
pub export_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopContinuousExportResponse {
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "stopTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stop_time: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopDataCollectionByAgentIdsRequest {
#[serde(rename = "agentIds")]
pub agent_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopDataCollectionByAgentIdsResponse {
#[serde(rename = "agentsConfigurationStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agents_configuration_status: Option<Vec<AgentConfigurationStatus>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Tag {
#[serde(rename = "key")]
pub key: String,
#[serde(rename = "value")]
pub value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagFilter {
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "values")]
pub values: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateApplicationRequest {
#[serde(rename = "configurationId")]
pub configuration_id: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateApplicationResponse {}
#[derive(Debug, PartialEq)]
pub enum AssociateConfigurationItemsToApplicationError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl AssociateConfigurationItemsToApplicationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateConfigurationItemsToApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(
AssociateConfigurationItemsToApplicationError::AuthorizationError(err.msg),
)
}
"HomeRegionNotSetException" => {
return RusotoError::Service(
AssociateConfigurationItemsToApplicationError::HomeRegionNotSet(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
AssociateConfigurationItemsToApplicationError::InvalidParameter(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
AssociateConfigurationItemsToApplicationError::InvalidParameterValue(
err.msg,
),
)
}
"ServerInternalErrorException" => {
return RusotoError::Service(
AssociateConfigurationItemsToApplicationError::ServerInternalError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateConfigurationItemsToApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateConfigurationItemsToApplicationError::AuthorizationError(ref cause) => {
write!(f, "{}", cause)
}
AssociateConfigurationItemsToApplicationError::HomeRegionNotSet(ref cause) => {
write!(f, "{}", cause)
}
AssociateConfigurationItemsToApplicationError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
AssociateConfigurationItemsToApplicationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
AssociateConfigurationItemsToApplicationError::ServerInternalError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateConfigurationItemsToApplicationError {}
#[derive(Debug, PartialEq)]
pub enum BatchDeleteImportDataError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl BatchDeleteImportDataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchDeleteImportDataError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(BatchDeleteImportDataError::AuthorizationError(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(BatchDeleteImportDataError::HomeRegionNotSet(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(BatchDeleteImportDataError::InvalidParameter(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(BatchDeleteImportDataError::InvalidParameterValue(
err.msg,
))
}
"ServerInternalErrorException" => {
return RusotoError::Service(BatchDeleteImportDataError::ServerInternalError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchDeleteImportDataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchDeleteImportDataError::AuthorizationError(ref cause) => write!(f, "{}", cause),
BatchDeleteImportDataError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
BatchDeleteImportDataError::InvalidParameter(ref cause) => write!(f, "{}", cause),
BatchDeleteImportDataError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
BatchDeleteImportDataError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchDeleteImportDataError {}
#[derive(Debug, PartialEq)]
pub enum CreateApplicationError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl CreateApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(CreateApplicationError::AuthorizationError(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(CreateApplicationError::HomeRegionNotSet(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateApplicationError::InvalidParameter(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(CreateApplicationError::InvalidParameterValue(
err.msg,
))
}
"ServerInternalErrorException" => {
return RusotoError::Service(CreateApplicationError::ServerInternalError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateApplicationError::AuthorizationError(ref cause) => write!(f, "{}", cause),
CreateApplicationError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
CreateApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateApplicationError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CreateApplicationError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateApplicationError {}
#[derive(Debug, PartialEq)]
pub enum CreateTagsError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ResourceNotFound(String),
ServerInternalError(String),
}
impl CreateTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTagsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(CreateTagsError::AuthorizationError(err.msg))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(CreateTagsError::HomeRegionNotSet(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateTagsError::InvalidParameter(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(CreateTagsError::InvalidParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateTagsError::ResourceNotFound(err.msg))
}
"ServerInternalErrorException" => {
return RusotoError::Service(CreateTagsError::ServerInternalError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTagsError::AuthorizationError(ref cause) => write!(f, "{}", cause),
CreateTagsError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
CreateTagsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateTagsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CreateTagsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateTagsError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTagsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationsError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl DeleteApplicationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteApplicationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(DeleteApplicationsError::AuthorizationError(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(DeleteApplicationsError::HomeRegionNotSet(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteApplicationsError::InvalidParameter(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(DeleteApplicationsError::InvalidParameterValue(
err.msg,
))
}
"ServerInternalErrorException" => {
return RusotoError::Service(DeleteApplicationsError::ServerInternalError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApplicationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApplicationsError::AuthorizationError(ref cause) => write!(f, "{}", cause),
DeleteApplicationsError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
DeleteApplicationsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteApplicationsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteApplicationsError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteApplicationsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTagsError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ResourceNotFound(String),
ServerInternalError(String),
}
impl DeleteTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTagsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(DeleteTagsError::AuthorizationError(err.msg))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(DeleteTagsError::HomeRegionNotSet(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteTagsError::InvalidParameter(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(DeleteTagsError::InvalidParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteTagsError::ResourceNotFound(err.msg))
}
"ServerInternalErrorException" => {
return RusotoError::Service(DeleteTagsError::ServerInternalError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTagsError::AuthorizationError(ref cause) => write!(f, "{}", cause),
DeleteTagsError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
DeleteTagsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteTagsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteTagsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteTagsError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTagsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAgentsError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl DescribeAgentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAgentsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(DescribeAgentsError::AuthorizationError(err.msg))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(DescribeAgentsError::HomeRegionNotSet(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeAgentsError::InvalidParameter(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(DescribeAgentsError::InvalidParameterValue(
err.msg,
))
}
"ServerInternalErrorException" => {
return RusotoError::Service(DescribeAgentsError::ServerInternalError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeAgentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAgentsError::AuthorizationError(ref cause) => write!(f, "{}", cause),
DescribeAgentsError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
DescribeAgentsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeAgentsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DescribeAgentsError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeAgentsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConfigurationsError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl DescribeConfigurationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeConfigurationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(DescribeConfigurationsError::AuthorizationError(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(DescribeConfigurationsError::HomeRegionNotSet(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeConfigurationsError::InvalidParameter(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribeConfigurationsError::InvalidParameterValue(err.msg),
)
}
"ServerInternalErrorException" => {
return RusotoError::Service(DescribeConfigurationsError::ServerInternalError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConfigurationsError::AuthorizationError(ref cause) => write!(f, "{}", cause),
DescribeConfigurationsError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
DescribeConfigurationsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeConfigurationsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DescribeConfigurationsError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeContinuousExportsError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
OperationNotPermitted(String),
ResourceNotFound(String),
ServerInternalError(String),
}
impl DescribeContinuousExportsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeContinuousExportsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(
DescribeContinuousExportsError::AuthorizationError(err.msg),
)
}
"HomeRegionNotSetException" => {
return RusotoError::Service(DescribeContinuousExportsError::HomeRegionNotSet(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeContinuousExportsError::InvalidParameter(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribeContinuousExportsError::InvalidParameterValue(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(
DescribeContinuousExportsError::OperationNotPermitted(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeContinuousExportsError::ResourceNotFound(
err.msg,
))
}
"ServerInternalErrorException" => {
return RusotoError::Service(
DescribeContinuousExportsError::ServerInternalError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeContinuousExportsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeContinuousExportsError::AuthorizationError(ref cause) => write!(f, "{}", cause),
DescribeContinuousExportsError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
DescribeContinuousExportsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeContinuousExportsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeContinuousExportsError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
DescribeContinuousExportsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeContinuousExportsError::ServerInternalError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeContinuousExportsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeExportConfigurationsError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ResourceNotFound(String),
ServerInternalError(String),
}
impl DescribeExportConfigurationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeExportConfigurationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(
DescribeExportConfigurationsError::AuthorizationError(err.msg),
)
}
"HomeRegionNotSetException" => {
return RusotoError::Service(
DescribeExportConfigurationsError::HomeRegionNotSet(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
DescribeExportConfigurationsError::InvalidParameter(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribeExportConfigurationsError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeExportConfigurationsError::ResourceNotFound(err.msg),
)
}
"ServerInternalErrorException" => {
return RusotoError::Service(
DescribeExportConfigurationsError::ServerInternalError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeExportConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeExportConfigurationsError::AuthorizationError(ref cause) => {
write!(f, "{}", cause)
}
DescribeExportConfigurationsError::HomeRegionNotSet(ref cause) => {
write!(f, "{}", cause)
}
DescribeExportConfigurationsError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
DescribeExportConfigurationsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeExportConfigurationsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeExportConfigurationsError::ServerInternalError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeExportConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeExportTasksError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl DescribeExportTasksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeExportTasksError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(DescribeExportTasksError::AuthorizationError(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(DescribeExportTasksError::HomeRegionNotSet(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeExportTasksError::InvalidParameter(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(DescribeExportTasksError::InvalidParameterValue(
err.msg,
))
}
"ServerInternalErrorException" => {
return RusotoError::Service(DescribeExportTasksError::ServerInternalError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeExportTasksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeExportTasksError::AuthorizationError(ref cause) => write!(f, "{}", cause),
DescribeExportTasksError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
DescribeExportTasksError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeExportTasksError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DescribeExportTasksError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeExportTasksError {}
#[derive(Debug, PartialEq)]
pub enum DescribeImportTasksError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl DescribeImportTasksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeImportTasksError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(DescribeImportTasksError::AuthorizationError(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(DescribeImportTasksError::HomeRegionNotSet(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeImportTasksError::InvalidParameter(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(DescribeImportTasksError::InvalidParameterValue(
err.msg,
))
}
"ServerInternalErrorException" => {
return RusotoError::Service(DescribeImportTasksError::ServerInternalError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeImportTasksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeImportTasksError::AuthorizationError(ref cause) => write!(f, "{}", cause),
DescribeImportTasksError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
DescribeImportTasksError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeImportTasksError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DescribeImportTasksError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeImportTasksError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTagsError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ResourceNotFound(String),
ServerInternalError(String),
}
impl DescribeTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTagsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(DescribeTagsError::AuthorizationError(err.msg))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(DescribeTagsError::HomeRegionNotSet(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeTagsError::InvalidParameter(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(DescribeTagsError::InvalidParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeTagsError::ResourceNotFound(err.msg))
}
"ServerInternalErrorException" => {
return RusotoError::Service(DescribeTagsError::ServerInternalError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTagsError::AuthorizationError(ref cause) => write!(f, "{}", cause),
DescribeTagsError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
DescribeTagsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeTagsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DescribeTagsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeTagsError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeTagsError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateConfigurationItemsFromApplicationError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl DisassociateConfigurationItemsFromApplicationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateConfigurationItemsFromApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(
DisassociateConfigurationItemsFromApplicationError::AuthorizationError(
err.msg,
),
)
}
"HomeRegionNotSetException" => {
return RusotoError::Service(
DisassociateConfigurationItemsFromApplicationError::HomeRegionNotSet(
err.msg,
),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
DisassociateConfigurationItemsFromApplicationError::InvalidParameter(
err.msg,
),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DisassociateConfigurationItemsFromApplicationError::InvalidParameterValue(
err.msg,
),
)
}
"ServerInternalErrorException" => {
return RusotoError::Service(
DisassociateConfigurationItemsFromApplicationError::ServerInternalError(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateConfigurationItemsFromApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateConfigurationItemsFromApplicationError::AuthorizationError(ref cause) => {
write!(f, "{}", cause)
}
DisassociateConfigurationItemsFromApplicationError::HomeRegionNotSet(ref cause) => {
write!(f, "{}", cause)
}
DisassociateConfigurationItemsFromApplicationError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
DisassociateConfigurationItemsFromApplicationError::InvalidParameterValue(
ref cause,
) => write!(f, "{}", cause),
DisassociateConfigurationItemsFromApplicationError::ServerInternalError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateConfigurationItemsFromApplicationError {}
#[derive(Debug, PartialEq)]
pub enum ExportConfigurationsError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
OperationNotPermitted(String),
ServerInternalError(String),
}
impl ExportConfigurationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ExportConfigurationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(ExportConfigurationsError::AuthorizationError(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(ExportConfigurationsError::HomeRegionNotSet(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ExportConfigurationsError::InvalidParameter(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(ExportConfigurationsError::InvalidParameterValue(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(ExportConfigurationsError::OperationNotPermitted(
err.msg,
))
}
"ServerInternalErrorException" => {
return RusotoError::Service(ExportConfigurationsError::ServerInternalError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ExportConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ExportConfigurationsError::AuthorizationError(ref cause) => write!(f, "{}", cause),
ExportConfigurationsError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
ExportConfigurationsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ExportConfigurationsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ExportConfigurationsError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
ExportConfigurationsError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ExportConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum GetDiscoverySummaryError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl GetDiscoverySummaryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDiscoverySummaryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(GetDiscoverySummaryError::AuthorizationError(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(GetDiscoverySummaryError::HomeRegionNotSet(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(GetDiscoverySummaryError::InvalidParameter(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(GetDiscoverySummaryError::InvalidParameterValue(
err.msg,
))
}
"ServerInternalErrorException" => {
return RusotoError::Service(GetDiscoverySummaryError::ServerInternalError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDiscoverySummaryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDiscoverySummaryError::AuthorizationError(ref cause) => write!(f, "{}", cause),
GetDiscoverySummaryError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
GetDiscoverySummaryError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetDiscoverySummaryError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetDiscoverySummaryError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDiscoverySummaryError {}
#[derive(Debug, PartialEq)]
pub enum ListConfigurationsError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ResourceNotFound(String),
ServerInternalError(String),
}
impl ListConfigurationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListConfigurationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(ListConfigurationsError::AuthorizationError(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(ListConfigurationsError::HomeRegionNotSet(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListConfigurationsError::InvalidParameter(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(ListConfigurationsError::InvalidParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListConfigurationsError::ResourceNotFound(err.msg))
}
"ServerInternalErrorException" => {
return RusotoError::Service(ListConfigurationsError::ServerInternalError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListConfigurationsError::AuthorizationError(ref cause) => write!(f, "{}", cause),
ListConfigurationsError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
ListConfigurationsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListConfigurationsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListConfigurationsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListConfigurationsError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum ListServerNeighborsError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl ListServerNeighborsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListServerNeighborsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(ListServerNeighborsError::AuthorizationError(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(ListServerNeighborsError::HomeRegionNotSet(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ListServerNeighborsError::InvalidParameter(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(ListServerNeighborsError::InvalidParameterValue(
err.msg,
))
}
"ServerInternalErrorException" => {
return RusotoError::Service(ListServerNeighborsError::ServerInternalError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListServerNeighborsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListServerNeighborsError::AuthorizationError(ref cause) => write!(f, "{}", cause),
ListServerNeighborsError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
ListServerNeighborsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListServerNeighborsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListServerNeighborsError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListServerNeighborsError {}
#[derive(Debug, PartialEq)]
pub enum StartContinuousExportError {
AuthorizationError(String),
ConflictError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
OperationNotPermitted(String),
ResourceInUse(String),
ServerInternalError(String),
}
impl StartContinuousExportError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartContinuousExportError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(StartContinuousExportError::AuthorizationError(
err.msg,
))
}
"ConflictErrorException" => {
return RusotoError::Service(StartContinuousExportError::ConflictError(err.msg))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(StartContinuousExportError::HomeRegionNotSet(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(StartContinuousExportError::InvalidParameter(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(StartContinuousExportError::InvalidParameterValue(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(StartContinuousExportError::OperationNotPermitted(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(StartContinuousExportError::ResourceInUse(err.msg))
}
"ServerInternalErrorException" => {
return RusotoError::Service(StartContinuousExportError::ServerInternalError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartContinuousExportError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartContinuousExportError::AuthorizationError(ref cause) => write!(f, "{}", cause),
StartContinuousExportError::ConflictError(ref cause) => write!(f, "{}", cause),
StartContinuousExportError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
StartContinuousExportError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StartContinuousExportError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
StartContinuousExportError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
StartContinuousExportError::ResourceInUse(ref cause) => write!(f, "{}", cause),
StartContinuousExportError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartContinuousExportError {}
#[derive(Debug, PartialEq)]
pub enum StartDataCollectionByAgentIdsError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl StartDataCollectionByAgentIdsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<StartDataCollectionByAgentIdsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(
StartDataCollectionByAgentIdsError::AuthorizationError(err.msg),
)
}
"HomeRegionNotSetException" => {
return RusotoError::Service(
StartDataCollectionByAgentIdsError::HomeRegionNotSet(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
StartDataCollectionByAgentIdsError::InvalidParameter(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
StartDataCollectionByAgentIdsError::InvalidParameterValue(err.msg),
)
}
"ServerInternalErrorException" => {
return RusotoError::Service(
StartDataCollectionByAgentIdsError::ServerInternalError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartDataCollectionByAgentIdsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartDataCollectionByAgentIdsError::AuthorizationError(ref cause) => {
write!(f, "{}", cause)
}
StartDataCollectionByAgentIdsError::HomeRegionNotSet(ref cause) => {
write!(f, "{}", cause)
}
StartDataCollectionByAgentIdsError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
StartDataCollectionByAgentIdsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
StartDataCollectionByAgentIdsError::ServerInternalError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for StartDataCollectionByAgentIdsError {}
#[derive(Debug, PartialEq)]
pub enum StartExportTaskError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
OperationNotPermitted(String),
ServerInternalError(String),
}
impl StartExportTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartExportTaskError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(StartExportTaskError::AuthorizationError(err.msg))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(StartExportTaskError::HomeRegionNotSet(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(StartExportTaskError::InvalidParameter(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(StartExportTaskError::InvalidParameterValue(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(StartExportTaskError::OperationNotPermitted(
err.msg,
))
}
"ServerInternalErrorException" => {
return RusotoError::Service(StartExportTaskError::ServerInternalError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartExportTaskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartExportTaskError::AuthorizationError(ref cause) => write!(f, "{}", cause),
StartExportTaskError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
StartExportTaskError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StartExportTaskError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
StartExportTaskError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
StartExportTaskError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartExportTaskError {}
#[derive(Debug, PartialEq)]
pub enum StartImportTaskError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ResourceInUse(String),
ServerInternalError(String),
}
impl StartImportTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartImportTaskError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(StartImportTaskError::AuthorizationError(err.msg))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(StartImportTaskError::HomeRegionNotSet(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(StartImportTaskError::InvalidParameter(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(StartImportTaskError::InvalidParameterValue(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(StartImportTaskError::ResourceInUse(err.msg))
}
"ServerInternalErrorException" => {
return RusotoError::Service(StartImportTaskError::ServerInternalError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartImportTaskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartImportTaskError::AuthorizationError(ref cause) => write!(f, "{}", cause),
StartImportTaskError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
StartImportTaskError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StartImportTaskError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
StartImportTaskError::ResourceInUse(ref cause) => write!(f, "{}", cause),
StartImportTaskError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartImportTaskError {}
#[derive(Debug, PartialEq)]
pub enum StopContinuousExportError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
OperationNotPermitted(String),
ResourceInUse(String),
ResourceNotFound(String),
ServerInternalError(String),
}
impl StopContinuousExportError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopContinuousExportError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(StopContinuousExportError::AuthorizationError(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(StopContinuousExportError::HomeRegionNotSet(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(StopContinuousExportError::InvalidParameter(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(StopContinuousExportError::InvalidParameterValue(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(StopContinuousExportError::OperationNotPermitted(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(StopContinuousExportError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StopContinuousExportError::ResourceNotFound(
err.msg,
))
}
"ServerInternalErrorException" => {
return RusotoError::Service(StopContinuousExportError::ServerInternalError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopContinuousExportError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopContinuousExportError::AuthorizationError(ref cause) => write!(f, "{}", cause),
StopContinuousExportError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
StopContinuousExportError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StopContinuousExportError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
StopContinuousExportError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
StopContinuousExportError::ResourceInUse(ref cause) => write!(f, "{}", cause),
StopContinuousExportError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StopContinuousExportError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopContinuousExportError {}
#[derive(Debug, PartialEq)]
pub enum StopDataCollectionByAgentIdsError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl StopDataCollectionByAgentIdsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<StopDataCollectionByAgentIdsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(
StopDataCollectionByAgentIdsError::AuthorizationError(err.msg),
)
}
"HomeRegionNotSetException" => {
return RusotoError::Service(
StopDataCollectionByAgentIdsError::HomeRegionNotSet(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
StopDataCollectionByAgentIdsError::InvalidParameter(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
StopDataCollectionByAgentIdsError::InvalidParameterValue(err.msg),
)
}
"ServerInternalErrorException" => {
return RusotoError::Service(
StopDataCollectionByAgentIdsError::ServerInternalError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopDataCollectionByAgentIdsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopDataCollectionByAgentIdsError::AuthorizationError(ref cause) => {
write!(f, "{}", cause)
}
StopDataCollectionByAgentIdsError::HomeRegionNotSet(ref cause) => {
write!(f, "{}", cause)
}
StopDataCollectionByAgentIdsError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
StopDataCollectionByAgentIdsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
StopDataCollectionByAgentIdsError::ServerInternalError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for StopDataCollectionByAgentIdsError {}
#[derive(Debug, PartialEq)]
pub enum UpdateApplicationError {
AuthorizationError(String),
HomeRegionNotSet(String),
InvalidParameter(String),
InvalidParameterValue(String),
ServerInternalError(String),
}
impl UpdateApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorizationErrorException" => {
return RusotoError::Service(UpdateApplicationError::AuthorizationError(
err.msg,
))
}
"HomeRegionNotSetException" => {
return RusotoError::Service(UpdateApplicationError::HomeRegionNotSet(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateApplicationError::InvalidParameter(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(UpdateApplicationError::InvalidParameterValue(
err.msg,
))
}
"ServerInternalErrorException" => {
return RusotoError::Service(UpdateApplicationError::ServerInternalError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateApplicationError::AuthorizationError(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::HomeRegionNotSet(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::ServerInternalError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateApplicationError {}
#[async_trait]
pub trait Discovery {
async fn associate_configuration_items_to_application(
&self,
input: AssociateConfigurationItemsToApplicationRequest,
) -> Result<
AssociateConfigurationItemsToApplicationResponse,
RusotoError<AssociateConfigurationItemsToApplicationError>,
>;
async fn batch_delete_import_data(
&self,
input: BatchDeleteImportDataRequest,
) -> Result<BatchDeleteImportDataResponse, RusotoError<BatchDeleteImportDataError>>;
async fn create_application(
&self,
input: CreateApplicationRequest,
) -> Result<CreateApplicationResponse, RusotoError<CreateApplicationError>>;
async fn create_tags(
&self,
input: CreateTagsRequest,
) -> Result<CreateTagsResponse, RusotoError<CreateTagsError>>;
async fn delete_applications(
&self,
input: DeleteApplicationsRequest,
) -> Result<DeleteApplicationsResponse, RusotoError<DeleteApplicationsError>>;
async fn delete_tags(
&self,
input: DeleteTagsRequest,
) -> Result<DeleteTagsResponse, RusotoError<DeleteTagsError>>;
async fn describe_agents(
&self,
input: DescribeAgentsRequest,
) -> Result<DescribeAgentsResponse, RusotoError<DescribeAgentsError>>;
async fn describe_configurations(
&self,
input: DescribeConfigurationsRequest,
) -> Result<DescribeConfigurationsResponse, RusotoError<DescribeConfigurationsError>>;
async fn describe_continuous_exports(
&self,
input: DescribeContinuousExportsRequest,
) -> Result<DescribeContinuousExportsResponse, RusotoError<DescribeContinuousExportsError>>;
async fn describe_export_configurations(
&self,
input: DescribeExportConfigurationsRequest,
) -> Result<DescribeExportConfigurationsResponse, RusotoError<DescribeExportConfigurationsError>>;
async fn describe_export_tasks(
&self,
input: DescribeExportTasksRequest,
) -> Result<DescribeExportTasksResponse, RusotoError<DescribeExportTasksError>>;
async fn describe_import_tasks(
&self,
input: DescribeImportTasksRequest,
) -> Result<DescribeImportTasksResponse, RusotoError<DescribeImportTasksError>>;
async fn describe_tags(
&self,
input: DescribeTagsRequest,
) -> Result<DescribeTagsResponse, RusotoError<DescribeTagsError>>;
async fn disassociate_configuration_items_from_application(
&self,
input: DisassociateConfigurationItemsFromApplicationRequest,
) -> Result<
DisassociateConfigurationItemsFromApplicationResponse,
RusotoError<DisassociateConfigurationItemsFromApplicationError>,
>;
async fn export_configurations(
&self,
) -> Result<ExportConfigurationsResponse, RusotoError<ExportConfigurationsError>>;
async fn get_discovery_summary(
&self,
) -> Result<GetDiscoverySummaryResponse, RusotoError<GetDiscoverySummaryError>>;
async fn list_configurations(
&self,
input: ListConfigurationsRequest,
) -> Result<ListConfigurationsResponse, RusotoError<ListConfigurationsError>>;
async fn list_server_neighbors(
&self,
input: ListServerNeighborsRequest,
) -> Result<ListServerNeighborsResponse, RusotoError<ListServerNeighborsError>>;
async fn start_continuous_export(
&self,
) -> Result<StartContinuousExportResponse, RusotoError<StartContinuousExportError>>;
async fn start_data_collection_by_agent_ids(
&self,
input: StartDataCollectionByAgentIdsRequest,
) -> Result<
StartDataCollectionByAgentIdsResponse,
RusotoError<StartDataCollectionByAgentIdsError>,
>;
async fn start_export_task(
&self,
input: StartExportTaskRequest,
) -> Result<StartExportTaskResponse, RusotoError<StartExportTaskError>>;
async fn start_import_task(
&self,
input: StartImportTaskRequest,
) -> Result<StartImportTaskResponse, RusotoError<StartImportTaskError>>;
async fn stop_continuous_export(
&self,
input: StopContinuousExportRequest,
) -> Result<StopContinuousExportResponse, RusotoError<StopContinuousExportError>>;
async fn stop_data_collection_by_agent_ids(
&self,
input: StopDataCollectionByAgentIdsRequest,
) -> Result<StopDataCollectionByAgentIdsResponse, RusotoError<StopDataCollectionByAgentIdsError>>;
async fn update_application(
&self,
input: UpdateApplicationRequest,
) -> Result<UpdateApplicationResponse, RusotoError<UpdateApplicationError>>;
}
#[derive(Clone)]
pub struct DiscoveryClient {
client: Client,
region: region::Region,
}
impl DiscoveryClient {
pub fn new(region: region::Region) -> DiscoveryClient {
DiscoveryClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> DiscoveryClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
DiscoveryClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> DiscoveryClient {
DiscoveryClient { client, region }
}
}
#[async_trait]
impl Discovery for DiscoveryClient {
async fn associate_configuration_items_to_application(
&self,
input: AssociateConfigurationItemsToApplicationRequest,
) -> Result<
AssociateConfigurationItemsToApplicationResponse,
RusotoError<AssociateConfigurationItemsToApplicationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.AssociateConfigurationItemsToApplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
AssociateConfigurationItemsToApplicationError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateConfigurationItemsToApplicationResponse, _>()
}
async fn batch_delete_import_data(
&self,
input: BatchDeleteImportDataRequest,
) -> Result<BatchDeleteImportDataResponse, RusotoError<BatchDeleteImportDataError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.BatchDeleteImportData",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchDeleteImportDataError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchDeleteImportDataResponse, _>()
}
async fn create_application(
&self,
input: CreateApplicationRequest,
) -> Result<CreateApplicationResponse, RusotoError<CreateApplicationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.CreateApplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateApplicationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateApplicationResponse, _>()
}
async fn create_tags(
&self,
input: CreateTagsRequest,
) -> Result<CreateTagsResponse, RusotoError<CreateTagsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSPoseidonService_V2015_11_01.CreateTags");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateTagsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateTagsResponse, _>()
}
async fn delete_applications(
&self,
input: DeleteApplicationsRequest,
) -> Result<DeleteApplicationsResponse, RusotoError<DeleteApplicationsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.DeleteApplications",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteApplicationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteApplicationsResponse, _>()
}
async fn delete_tags(
&self,
input: DeleteTagsRequest,
) -> Result<DeleteTagsResponse, RusotoError<DeleteTagsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSPoseidonService_V2015_11_01.DeleteTags");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteTagsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteTagsResponse, _>()
}
async fn describe_agents(
&self,
input: DescribeAgentsRequest,
) -> Result<DescribeAgentsResponse, RusotoError<DescribeAgentsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.DescribeAgents",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeAgentsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeAgentsResponse, _>()
}
async fn describe_configurations(
&self,
input: DescribeConfigurationsRequest,
) -> Result<DescribeConfigurationsResponse, RusotoError<DescribeConfigurationsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.DescribeConfigurations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeConfigurationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeConfigurationsResponse, _>()
}
async fn describe_continuous_exports(
&self,
input: DescribeContinuousExportsRequest,
) -> Result<DescribeContinuousExportsResponse, RusotoError<DescribeContinuousExportsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.DescribeContinuousExports",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeContinuousExportsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeContinuousExportsResponse, _>()
}
async fn describe_export_configurations(
&self,
input: DescribeExportConfigurationsRequest,
) -> Result<DescribeExportConfigurationsResponse, RusotoError<DescribeExportConfigurationsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.DescribeExportConfigurations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeExportConfigurationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeExportConfigurationsResponse, _>()
}
async fn describe_export_tasks(
&self,
input: DescribeExportTasksRequest,
) -> Result<DescribeExportTasksResponse, RusotoError<DescribeExportTasksError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.DescribeExportTasks",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeExportTasksError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeExportTasksResponse, _>()
}
async fn describe_import_tasks(
&self,
input: DescribeImportTasksRequest,
) -> Result<DescribeImportTasksResponse, RusotoError<DescribeImportTasksError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.DescribeImportTasks",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeImportTasksError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeImportTasksResponse, _>()
}
async fn describe_tags(
&self,
input: DescribeTagsRequest,
) -> Result<DescribeTagsResponse, RusotoError<DescribeTagsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.DescribeTags",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeTagsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeTagsResponse, _>()
}
async fn disassociate_configuration_items_from_application(
&self,
input: DisassociateConfigurationItemsFromApplicationRequest,
) -> Result<
DisassociateConfigurationItemsFromApplicationResponse,
RusotoError<DisassociateConfigurationItemsFromApplicationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.DisassociateConfigurationItemsFromApplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DisassociateConfigurationItemsFromApplicationError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateConfigurationItemsFromApplicationResponse, _>()
}
async fn export_configurations(
&self,
) -> Result<ExportConfigurationsResponse, RusotoError<ExportConfigurationsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.ExportConfigurations",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, ExportConfigurationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ExportConfigurationsResponse, _>()
}
async fn get_discovery_summary(
&self,
) -> Result<GetDiscoverySummaryResponse, RusotoError<GetDiscoverySummaryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.GetDiscoverySummary",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, GetDiscoverySummaryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDiscoverySummaryResponse, _>()
}
async fn list_configurations(
&self,
input: ListConfigurationsRequest,
) -> Result<ListConfigurationsResponse, RusotoError<ListConfigurationsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.ListConfigurations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListConfigurationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListConfigurationsResponse, _>()
}
async fn list_server_neighbors(
&self,
input: ListServerNeighborsRequest,
) -> Result<ListServerNeighborsResponse, RusotoError<ListServerNeighborsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.ListServerNeighbors",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListServerNeighborsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListServerNeighborsResponse, _>()
}
async fn start_continuous_export(
&self,
) -> Result<StartContinuousExportResponse, RusotoError<StartContinuousExportError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.StartContinuousExport",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, StartContinuousExportError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartContinuousExportResponse, _>()
}
async fn start_data_collection_by_agent_ids(
&self,
input: StartDataCollectionByAgentIdsRequest,
) -> Result<
StartDataCollectionByAgentIdsResponse,
RusotoError<StartDataCollectionByAgentIdsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.StartDataCollectionByAgentIds",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartDataCollectionByAgentIdsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartDataCollectionByAgentIdsResponse, _>()
}
async fn start_export_task(
&self,
input: StartExportTaskRequest,
) -> Result<StartExportTaskResponse, RusotoError<StartExportTaskError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.StartExportTask",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartExportTaskError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StartExportTaskResponse, _>()
}
async fn start_import_task(
&self,
input: StartImportTaskRequest,
) -> Result<StartImportTaskResponse, RusotoError<StartImportTaskError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.StartImportTask",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartImportTaskError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StartImportTaskResponse, _>()
}
async fn stop_continuous_export(
&self,
input: StopContinuousExportRequest,
) -> Result<StopContinuousExportResponse, RusotoError<StopContinuousExportError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.StopContinuousExport",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopContinuousExportError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StopContinuousExportResponse, _>()
}
async fn stop_data_collection_by_agent_ids(
&self,
input: StopDataCollectionByAgentIdsRequest,
) -> Result<StopDataCollectionByAgentIdsResponse, RusotoError<StopDataCollectionByAgentIdsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.StopDataCollectionByAgentIds",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopDataCollectionByAgentIdsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StopDataCollectionByAgentIdsResponse, _>()
}
async fn update_application(
&self,
input: UpdateApplicationRequest,
) -> Result<UpdateApplicationResponse, RusotoError<UpdateApplicationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSPoseidonService_V2015_11_01.UpdateApplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateApplicationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateApplicationResponse, _>()
}
}