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 DataSyncClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "datasync", &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 AgentListEntry {
#[serde(rename = "AgentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[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 CancelTaskExecutionRequest {
#[serde(rename = "TaskExecutionArn")]
pub task_execution_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CancelTaskExecutionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateAgentRequest {
#[serde(rename = "ActivationKey")]
pub activation_key: String,
#[serde(rename = "AgentName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_name: Option<String>,
#[serde(rename = "SecurityGroupArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_arns: Option<Vec<String>>,
#[serde(rename = "SubnetArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_arns: Option<Vec<String>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<TagListEntry>>,
#[serde(rename = "VpcEndpointId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_endpoint_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateAgentResponse {
#[serde(rename = "AgentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLocationEfsRequest {
#[serde(rename = "Ec2Config")]
pub ec_2_config: Ec2Config,
#[serde(rename = "EfsFilesystemArn")]
pub efs_filesystem_arn: String,
#[serde(rename = "Subdirectory")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subdirectory: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<TagListEntry>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLocationEfsResponse {
#[serde(rename = "LocationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLocationFsxWindowsRequest {
#[serde(rename = "Domain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain: Option<String>,
#[serde(rename = "FsxFilesystemArn")]
pub fsx_filesystem_arn: String,
#[serde(rename = "Password")]
pub password: String,
#[serde(rename = "SecurityGroupArns")]
pub security_group_arns: Vec<String>,
#[serde(rename = "Subdirectory")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subdirectory: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<TagListEntry>>,
#[serde(rename = "User")]
pub user: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLocationFsxWindowsResponse {
#[serde(rename = "LocationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLocationNfsRequest {
#[serde(rename = "MountOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mount_options: Option<NfsMountOptions>,
#[serde(rename = "OnPremConfig")]
pub on_prem_config: OnPremConfig,
#[serde(rename = "ServerHostname")]
pub server_hostname: String,
#[serde(rename = "Subdirectory")]
pub subdirectory: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<TagListEntry>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLocationNfsResponse {
#[serde(rename = "LocationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLocationS3Request {
#[serde(rename = "S3BucketArn")]
pub s3_bucket_arn: String,
#[serde(rename = "S3Config")]
pub s3_config: S3Config,
#[serde(rename = "S3StorageClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_storage_class: Option<String>,
#[serde(rename = "Subdirectory")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subdirectory: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<TagListEntry>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLocationS3Response {
#[serde(rename = "LocationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLocationSmbRequest {
#[serde(rename = "AgentArns")]
pub agent_arns: Vec<String>,
#[serde(rename = "Domain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain: Option<String>,
#[serde(rename = "MountOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mount_options: Option<SmbMountOptions>,
#[serde(rename = "Password")]
pub password: String,
#[serde(rename = "ServerHostname")]
pub server_hostname: String,
#[serde(rename = "Subdirectory")]
pub subdirectory: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<TagListEntry>>,
#[serde(rename = "User")]
pub user: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLocationSmbResponse {
#[serde(rename = "LocationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTaskRequest {
#[serde(rename = "CloudWatchLogGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_log_group_arn: Option<String>,
#[serde(rename = "DestinationLocationArn")]
pub destination_location_arn: String,
#[serde(rename = "Excludes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub excludes: Option<Vec<FilterRule>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Options")]
#[serde(skip_serializing_if = "Option::is_none")]
pub options: Option<Options>,
#[serde(rename = "Schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<TaskSchedule>,
#[serde(rename = "SourceLocationArn")]
pub source_location_arn: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<TagListEntry>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTaskResponse {
#[serde(rename = "TaskArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAgentRequest {
#[serde(rename = "AgentArn")]
pub agent_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteAgentResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteLocationRequest {
#[serde(rename = "LocationArn")]
pub location_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteLocationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTaskRequest {
#[serde(rename = "TaskArn")]
pub task_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTaskResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAgentRequest {
#[serde(rename = "AgentArn")]
pub agent_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAgentResponse {
#[serde(rename = "AgentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_arn: Option<String>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "EndpointType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_type: Option<String>,
#[serde(rename = "LastConnectionTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_connection_time: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "PrivateLinkConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_link_config: Option<PrivateLinkConfig>,
#[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 DescribeLocationEfsRequest {
#[serde(rename = "LocationArn")]
pub location_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeLocationEfsResponse {
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "Ec2Config")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_config: Option<Ec2Config>,
#[serde(rename = "LocationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_arn: Option<String>,
#[serde(rename = "LocationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_uri: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeLocationFsxWindowsRequest {
#[serde(rename = "LocationArn")]
pub location_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeLocationFsxWindowsResponse {
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "Domain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain: Option<String>,
#[serde(rename = "LocationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_arn: Option<String>,
#[serde(rename = "LocationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_uri: Option<String>,
#[serde(rename = "SecurityGroupArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_arns: Option<Vec<String>>,
#[serde(rename = "User")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeLocationNfsRequest {
#[serde(rename = "LocationArn")]
pub location_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeLocationNfsResponse {
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "LocationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_arn: Option<String>,
#[serde(rename = "LocationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_uri: Option<String>,
#[serde(rename = "MountOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mount_options: Option<NfsMountOptions>,
#[serde(rename = "OnPremConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub on_prem_config: Option<OnPremConfig>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeLocationS3Request {
#[serde(rename = "LocationArn")]
pub location_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeLocationS3Response {
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "LocationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_arn: Option<String>,
#[serde(rename = "LocationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_uri: Option<String>,
#[serde(rename = "S3Config")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_config: Option<S3Config>,
#[serde(rename = "S3StorageClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_storage_class: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeLocationSmbRequest {
#[serde(rename = "LocationArn")]
pub location_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeLocationSmbResponse {
#[serde(rename = "AgentArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_arns: Option<Vec<String>>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "Domain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain: Option<String>,
#[serde(rename = "LocationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_arn: Option<String>,
#[serde(rename = "LocationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_uri: Option<String>,
#[serde(rename = "MountOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mount_options: Option<SmbMountOptions>,
#[serde(rename = "User")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTaskExecutionRequest {
#[serde(rename = "TaskExecutionArn")]
pub task_execution_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTaskExecutionResponse {
#[serde(rename = "BytesTransferred")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bytes_transferred: Option<i64>,
#[serde(rename = "BytesWritten")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bytes_written: Option<i64>,
#[serde(rename = "EstimatedBytesToTransfer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub estimated_bytes_to_transfer: Option<i64>,
#[serde(rename = "EstimatedFilesToTransfer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub estimated_files_to_transfer: Option<i64>,
#[serde(rename = "Excludes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub excludes: Option<Vec<FilterRule>>,
#[serde(rename = "FilesTransferred")]
#[serde(skip_serializing_if = "Option::is_none")]
pub files_transferred: Option<i64>,
#[serde(rename = "Includes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub includes: Option<Vec<FilterRule>>,
#[serde(rename = "Options")]
#[serde(skip_serializing_if = "Option::is_none")]
pub options: Option<Options>,
#[serde(rename = "Result")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result: Option<TaskExecutionResultDetail>,
#[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 = "TaskExecutionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_execution_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTaskRequest {
#[serde(rename = "TaskArn")]
pub task_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTaskResponse {
#[serde(rename = "CloudWatchLogGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_log_group_arn: Option<String>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "CurrentTaskExecutionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_task_execution_arn: Option<String>,
#[serde(rename = "DestinationLocationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_location_arn: Option<String>,
#[serde(rename = "DestinationNetworkInterfaceArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_network_interface_arns: Option<Vec<String>>,
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_detail: Option<String>,
#[serde(rename = "Excludes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub excludes: Option<Vec<FilterRule>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Options")]
#[serde(skip_serializing_if = "Option::is_none")]
pub options: Option<Options>,
#[serde(rename = "Schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<TaskSchedule>,
#[serde(rename = "SourceLocationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_location_arn: Option<String>,
#[serde(rename = "SourceNetworkInterfaceArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_network_interface_arns: Option<Vec<String>>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "TaskArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Ec2Config {
#[serde(rename = "SecurityGroupArns")]
pub security_group_arns: Vec<String>,
#[serde(rename = "SubnetArn")]
pub subnet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FilterRule {
#[serde(rename = "FilterType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_type: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAgentsRequest {
#[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 ListAgentsResponse {
#[serde(rename = "Agents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub agents: Option<Vec<AgentListEntry>>,
#[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 ListLocationsRequest {
#[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 ListLocationsResponse {
#[serde(rename = "Locations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub locations: Option<Vec<LocationListEntry>>,
#[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 ListTagsForResourceRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[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<TagListEntry>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTaskExecutionsRequest {
#[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 = "TaskArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTaskExecutionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "TaskExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_executions: Option<Vec<TaskExecutionListEntry>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTasksRequest {
#[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 ListTasksResponse {
#[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<TaskListEntry>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LocationListEntry {
#[serde(rename = "LocationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_arn: Option<String>,
#[serde(rename = "LocationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_uri: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct NfsMountOptions {
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OnPremConfig {
#[serde(rename = "AgentArns")]
pub agent_arns: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Options {
#[serde(rename = "Atime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub atime: Option<String>,
#[serde(rename = "BytesPerSecond")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bytes_per_second: Option<i64>,
#[serde(rename = "Gid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gid: Option<String>,
#[serde(rename = "LogLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_level: Option<String>,
#[serde(rename = "Mtime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mtime: Option<String>,
#[serde(rename = "OverwriteMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub overwrite_mode: Option<String>,
#[serde(rename = "PosixPermissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub posix_permissions: Option<String>,
#[serde(rename = "PreserveDeletedFiles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preserve_deleted_files: Option<String>,
#[serde(rename = "PreserveDevices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preserve_devices: Option<String>,
#[serde(rename = "TaskQueueing")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_queueing: Option<String>,
#[serde(rename = "Uid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uid: Option<String>,
#[serde(rename = "VerifyMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub verify_mode: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PrivateLinkConfig {
#[serde(rename = "PrivateLinkEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_link_endpoint: Option<String>,
#[serde(rename = "SecurityGroupArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_arns: Option<Vec<String>>,
#[serde(rename = "SubnetArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_arns: Option<Vec<String>>,
#[serde(rename = "VpcEndpointId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_endpoint_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct S3Config {
#[serde(rename = "BucketAccessRoleArn")]
pub bucket_access_role_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SmbMountOptions {
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartTaskExecutionRequest {
#[serde(rename = "Includes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub includes: Option<Vec<FilterRule>>,
#[serde(rename = "OverrideOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub override_options: Option<Options>,
#[serde(rename = "TaskArn")]
pub task_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartTaskExecutionResponse {
#[serde(rename = "TaskExecutionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_execution_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TagListEntry {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<TagListEntry>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TaskExecutionListEntry {
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "TaskExecutionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_execution_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TaskExecutionResultDetail {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_detail: Option<String>,
#[serde(rename = "PrepareDuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub prepare_duration: Option<i64>,
#[serde(rename = "PrepareStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub prepare_status: Option<String>,
#[serde(rename = "TotalDuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_duration: Option<i64>,
#[serde(rename = "TransferDuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transfer_duration: Option<i64>,
#[serde(rename = "TransferStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transfer_status: Option<String>,
#[serde(rename = "VerifyDuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub verify_duration: Option<i64>,
#[serde(rename = "VerifyStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub verify_status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TaskListEntry {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "TaskArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub task_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TaskSchedule {
#[serde(rename = "ScheduleExpression")]
pub schedule_expression: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "Keys")]
pub keys: Vec<String>,
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateAgentRequest {
#[serde(rename = "AgentArn")]
pub agent_arn: 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 UpdateAgentResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateTaskRequest {
#[serde(rename = "CloudWatchLogGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_log_group_arn: Option<String>,
#[serde(rename = "Excludes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub excludes: Option<Vec<FilterRule>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Options")]
#[serde(skip_serializing_if = "Option::is_none")]
pub options: Option<Options>,
#[serde(rename = "Schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<TaskSchedule>,
#[serde(rename = "TaskArn")]
pub task_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateTaskResponse {}
#[derive(Debug, PartialEq)]
pub enum CancelTaskExecutionError {
Internal(String),
InvalidRequest(String),
}
impl CancelTaskExecutionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelTaskExecutionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(CancelTaskExecutionError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CancelTaskExecutionError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CancelTaskExecutionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelTaskExecutionError::Internal(ref cause) => write!(f, "{}", cause),
CancelTaskExecutionError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelTaskExecutionError {}
#[derive(Debug, PartialEq)]
pub enum CreateAgentError {
Internal(String),
InvalidRequest(String),
}
impl CreateAgentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateAgentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(CreateAgentError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateAgentError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateAgentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateAgentError::Internal(ref cause) => write!(f, "{}", cause),
CreateAgentError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateAgentError {}
#[derive(Debug, PartialEq)]
pub enum CreateLocationEfsError {
Internal(String),
InvalidRequest(String),
}
impl CreateLocationEfsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLocationEfsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(CreateLocationEfsError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateLocationEfsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLocationEfsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLocationEfsError::Internal(ref cause) => write!(f, "{}", cause),
CreateLocationEfsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLocationEfsError {}
#[derive(Debug, PartialEq)]
pub enum CreateLocationFsxWindowsError {
Internal(String),
InvalidRequest(String),
}
impl CreateLocationFsxWindowsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLocationFsxWindowsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(CreateLocationFsxWindowsError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateLocationFsxWindowsError::InvalidRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLocationFsxWindowsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLocationFsxWindowsError::Internal(ref cause) => write!(f, "{}", cause),
CreateLocationFsxWindowsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLocationFsxWindowsError {}
#[derive(Debug, PartialEq)]
pub enum CreateLocationNfsError {
Internal(String),
InvalidRequest(String),
}
impl CreateLocationNfsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLocationNfsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(CreateLocationNfsError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateLocationNfsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLocationNfsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLocationNfsError::Internal(ref cause) => write!(f, "{}", cause),
CreateLocationNfsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLocationNfsError {}
#[derive(Debug, PartialEq)]
pub enum CreateLocationS3Error {
Internal(String),
InvalidRequest(String),
}
impl CreateLocationS3Error {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLocationS3Error> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(CreateLocationS3Error::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateLocationS3Error::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLocationS3Error {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLocationS3Error::Internal(ref cause) => write!(f, "{}", cause),
CreateLocationS3Error::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLocationS3Error {}
#[derive(Debug, PartialEq)]
pub enum CreateLocationSmbError {
Internal(String),
InvalidRequest(String),
}
impl CreateLocationSmbError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLocationSmbError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(CreateLocationSmbError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateLocationSmbError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLocationSmbError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLocationSmbError::Internal(ref cause) => write!(f, "{}", cause),
CreateLocationSmbError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLocationSmbError {}
#[derive(Debug, PartialEq)]
pub enum CreateTaskError {
Internal(String),
InvalidRequest(String),
}
impl CreateTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTaskError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(CreateTaskError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateTaskError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateTaskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTaskError::Internal(ref cause) => write!(f, "{}", cause),
CreateTaskError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTaskError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAgentError {
Internal(String),
InvalidRequest(String),
}
impl DeleteAgentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAgentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(DeleteAgentError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteAgentError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAgentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAgentError::Internal(ref cause) => write!(f, "{}", cause),
DeleteAgentError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteAgentError {}
#[derive(Debug, PartialEq)]
pub enum DeleteLocationError {
Internal(String),
InvalidRequest(String),
}
impl DeleteLocationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteLocationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(DeleteLocationError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteLocationError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLocationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLocationError::Internal(ref cause) => write!(f, "{}", cause),
DeleteLocationError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteLocationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTaskError {
Internal(String),
InvalidRequest(String),
}
impl DeleteTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTaskError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(DeleteTaskError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteTaskError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteTaskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTaskError::Internal(ref cause) => write!(f, "{}", cause),
DeleteTaskError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTaskError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAgentError {
Internal(String),
InvalidRequest(String),
}
impl DescribeAgentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAgentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(DescribeAgentError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeAgentError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeAgentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAgentError::Internal(ref cause) => write!(f, "{}", cause),
DescribeAgentError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeAgentError {}
#[derive(Debug, PartialEq)]
pub enum DescribeLocationEfsError {
Internal(String),
InvalidRequest(String),
}
impl DescribeLocationEfsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLocationEfsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(DescribeLocationEfsError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeLocationEfsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeLocationEfsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLocationEfsError::Internal(ref cause) => write!(f, "{}", cause),
DescribeLocationEfsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLocationEfsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeLocationFsxWindowsError {
Internal(String),
InvalidRequest(String),
}
impl DescribeLocationFsxWindowsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeLocationFsxWindowsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(DescribeLocationFsxWindowsError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeLocationFsxWindowsError::InvalidRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeLocationFsxWindowsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLocationFsxWindowsError::Internal(ref cause) => write!(f, "{}", cause),
DescribeLocationFsxWindowsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLocationFsxWindowsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeLocationNfsError {
Internal(String),
InvalidRequest(String),
}
impl DescribeLocationNfsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLocationNfsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(DescribeLocationNfsError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeLocationNfsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeLocationNfsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLocationNfsError::Internal(ref cause) => write!(f, "{}", cause),
DescribeLocationNfsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLocationNfsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeLocationS3Error {
Internal(String),
InvalidRequest(String),
}
impl DescribeLocationS3Error {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLocationS3Error> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(DescribeLocationS3Error::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeLocationS3Error::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeLocationS3Error {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLocationS3Error::Internal(ref cause) => write!(f, "{}", cause),
DescribeLocationS3Error::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLocationS3Error {}
#[derive(Debug, PartialEq)]
pub enum DescribeLocationSmbError {
Internal(String),
InvalidRequest(String),
}
impl DescribeLocationSmbError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLocationSmbError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(DescribeLocationSmbError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeLocationSmbError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeLocationSmbError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLocationSmbError::Internal(ref cause) => write!(f, "{}", cause),
DescribeLocationSmbError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLocationSmbError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTaskError {
Internal(String),
InvalidRequest(String),
}
impl DescribeTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTaskError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(DescribeTaskError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeTaskError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeTaskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTaskError::Internal(ref cause) => write!(f, "{}", cause),
DescribeTaskError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeTaskError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTaskExecutionError {
Internal(String),
InvalidRequest(String),
}
impl DescribeTaskExecutionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTaskExecutionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(DescribeTaskExecutionError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeTaskExecutionError::InvalidRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeTaskExecutionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTaskExecutionError::Internal(ref cause) => write!(f, "{}", cause),
DescribeTaskExecutionError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeTaskExecutionError {}
#[derive(Debug, PartialEq)]
pub enum ListAgentsError {
Internal(String),
InvalidRequest(String),
}
impl ListAgentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAgentsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(ListAgentsError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListAgentsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAgentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAgentsError::Internal(ref cause) => write!(f, "{}", cause),
ListAgentsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListAgentsError {}
#[derive(Debug, PartialEq)]
pub enum ListLocationsError {
Internal(String),
InvalidRequest(String),
}
impl ListLocationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLocationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(ListLocationsError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListLocationsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLocationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLocationsError::Internal(ref cause) => write!(f, "{}", cause),
ListLocationsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLocationsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
Internal(String),
InvalidRequest(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(ListTagsForResourceError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::Internal(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListTaskExecutionsError {
Internal(String),
InvalidRequest(String),
}
impl ListTaskExecutionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTaskExecutionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(ListTaskExecutionsError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListTaskExecutionsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTaskExecutionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTaskExecutionsError::Internal(ref cause) => write!(f, "{}", cause),
ListTaskExecutionsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTaskExecutionsError {}
#[derive(Debug, PartialEq)]
pub enum ListTasksError {
Internal(String),
InvalidRequest(String),
}
impl ListTasksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTasksError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(ListTasksError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListTasksError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTasksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTasksError::Internal(ref cause) => write!(f, "{}", cause),
ListTasksError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTasksError {}
#[derive(Debug, PartialEq)]
pub enum StartTaskExecutionError {
Internal(String),
InvalidRequest(String),
}
impl StartTaskExecutionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartTaskExecutionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(StartTaskExecutionError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(StartTaskExecutionError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartTaskExecutionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartTaskExecutionError::Internal(ref cause) => write!(f, "{}", cause),
StartTaskExecutionError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartTaskExecutionError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
Internal(String),
InvalidRequest(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(TagResourceError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(TagResourceError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::Internal(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
Internal(String),
InvalidRequest(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(UntagResourceError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UntagResourceError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::Internal(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateAgentError {
Internal(String),
InvalidRequest(String),
}
impl UpdateAgentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateAgentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(UpdateAgentError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateAgentError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateAgentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateAgentError::Internal(ref cause) => write!(f, "{}", cause),
UpdateAgentError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateAgentError {}
#[derive(Debug, PartialEq)]
pub enum UpdateTaskError {
Internal(String),
InvalidRequest(String),
}
impl UpdateTaskError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateTaskError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalException" => {
return RusotoError::Service(UpdateTaskError::Internal(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateTaskError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateTaskError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateTaskError::Internal(ref cause) => write!(f, "{}", cause),
UpdateTaskError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateTaskError {}
#[async_trait]
pub trait DataSync {
async fn cancel_task_execution(
&self,
input: CancelTaskExecutionRequest,
) -> Result<CancelTaskExecutionResponse, RusotoError<CancelTaskExecutionError>>;
async fn create_agent(
&self,
input: CreateAgentRequest,
) -> Result<CreateAgentResponse, RusotoError<CreateAgentError>>;
async fn create_location_efs(
&self,
input: CreateLocationEfsRequest,
) -> Result<CreateLocationEfsResponse, RusotoError<CreateLocationEfsError>>;
async fn create_location_fsx_windows(
&self,
input: CreateLocationFsxWindowsRequest,
) -> Result<CreateLocationFsxWindowsResponse, RusotoError<CreateLocationFsxWindowsError>>;
async fn create_location_nfs(
&self,
input: CreateLocationNfsRequest,
) -> Result<CreateLocationNfsResponse, RusotoError<CreateLocationNfsError>>;
async fn create_location_s3(
&self,
input: CreateLocationS3Request,
) -> Result<CreateLocationS3Response, RusotoError<CreateLocationS3Error>>;
async fn create_location_smb(
&self,
input: CreateLocationSmbRequest,
) -> Result<CreateLocationSmbResponse, RusotoError<CreateLocationSmbError>>;
async fn create_task(
&self,
input: CreateTaskRequest,
) -> Result<CreateTaskResponse, RusotoError<CreateTaskError>>;
async fn delete_agent(
&self,
input: DeleteAgentRequest,
) -> Result<DeleteAgentResponse, RusotoError<DeleteAgentError>>;
async fn delete_location(
&self,
input: DeleteLocationRequest,
) -> Result<DeleteLocationResponse, RusotoError<DeleteLocationError>>;
async fn delete_task(
&self,
input: DeleteTaskRequest,
) -> Result<DeleteTaskResponse, RusotoError<DeleteTaskError>>;
async fn describe_agent(
&self,
input: DescribeAgentRequest,
) -> Result<DescribeAgentResponse, RusotoError<DescribeAgentError>>;
async fn describe_location_efs(
&self,
input: DescribeLocationEfsRequest,
) -> Result<DescribeLocationEfsResponse, RusotoError<DescribeLocationEfsError>>;
async fn describe_location_fsx_windows(
&self,
input: DescribeLocationFsxWindowsRequest,
) -> Result<DescribeLocationFsxWindowsResponse, RusotoError<DescribeLocationFsxWindowsError>>;
async fn describe_location_nfs(
&self,
input: DescribeLocationNfsRequest,
) -> Result<DescribeLocationNfsResponse, RusotoError<DescribeLocationNfsError>>;
async fn describe_location_s3(
&self,
input: DescribeLocationS3Request,
) -> Result<DescribeLocationS3Response, RusotoError<DescribeLocationS3Error>>;
async fn describe_location_smb(
&self,
input: DescribeLocationSmbRequest,
) -> Result<DescribeLocationSmbResponse, RusotoError<DescribeLocationSmbError>>;
async fn describe_task(
&self,
input: DescribeTaskRequest,
) -> Result<DescribeTaskResponse, RusotoError<DescribeTaskError>>;
async fn describe_task_execution(
&self,
input: DescribeTaskExecutionRequest,
) -> Result<DescribeTaskExecutionResponse, RusotoError<DescribeTaskExecutionError>>;
async fn list_agents(
&self,
input: ListAgentsRequest,
) -> Result<ListAgentsResponse, RusotoError<ListAgentsError>>;
async fn list_locations(
&self,
input: ListLocationsRequest,
) -> Result<ListLocationsResponse, RusotoError<ListLocationsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn list_task_executions(
&self,
input: ListTaskExecutionsRequest,
) -> Result<ListTaskExecutionsResponse, RusotoError<ListTaskExecutionsError>>;
async fn list_tasks(
&self,
input: ListTasksRequest,
) -> Result<ListTasksResponse, RusotoError<ListTasksError>>;
async fn start_task_execution(
&self,
input: StartTaskExecutionRequest,
) -> Result<StartTaskExecutionResponse, RusotoError<StartTaskExecutionError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_agent(
&self,
input: UpdateAgentRequest,
) -> Result<UpdateAgentResponse, RusotoError<UpdateAgentError>>;
async fn update_task(
&self,
input: UpdateTaskRequest,
) -> Result<UpdateTaskResponse, RusotoError<UpdateTaskError>>;
}
#[derive(Clone)]
pub struct DataSyncClient {
client: Client,
region: region::Region,
}
impl DataSyncClient {
pub fn new(region: region::Region) -> DataSyncClient {
DataSyncClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> DataSyncClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
DataSyncClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> DataSyncClient {
DataSyncClient { client, region }
}
}
#[async_trait]
impl DataSync for DataSyncClient {
async fn cancel_task_execution(
&self,
input: CancelTaskExecutionRequest,
) -> Result<CancelTaskExecutionResponse, RusotoError<CancelTaskExecutionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.CancelTaskExecution");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CancelTaskExecutionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CancelTaskExecutionResponse, _>()
}
async fn create_agent(
&self,
input: CreateAgentRequest,
) -> Result<CreateAgentResponse, RusotoError<CreateAgentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.CreateAgent");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateAgentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateAgentResponse, _>()
}
async fn create_location_efs(
&self,
input: CreateLocationEfsRequest,
) -> Result<CreateLocationEfsResponse, RusotoError<CreateLocationEfsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.CreateLocationEfs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateLocationEfsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateLocationEfsResponse, _>()
}
async fn create_location_fsx_windows(
&self,
input: CreateLocationFsxWindowsRequest,
) -> Result<CreateLocationFsxWindowsResponse, RusotoError<CreateLocationFsxWindowsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.CreateLocationFsxWindows");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateLocationFsxWindowsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateLocationFsxWindowsResponse, _>()
}
async fn create_location_nfs(
&self,
input: CreateLocationNfsRequest,
) -> Result<CreateLocationNfsResponse, RusotoError<CreateLocationNfsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.CreateLocationNfs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateLocationNfsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateLocationNfsResponse, _>()
}
async fn create_location_s3(
&self,
input: CreateLocationS3Request,
) -> Result<CreateLocationS3Response, RusotoError<CreateLocationS3Error>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.CreateLocationS3");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateLocationS3Error::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateLocationS3Response, _>()
}
async fn create_location_smb(
&self,
input: CreateLocationSmbRequest,
) -> Result<CreateLocationSmbResponse, RusotoError<CreateLocationSmbError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.CreateLocationSmb");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateLocationSmbError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateLocationSmbResponse, _>()
}
async fn create_task(
&self,
input: CreateTaskRequest,
) -> Result<CreateTaskResponse, RusotoError<CreateTaskError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.CreateTask");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateTaskError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateTaskResponse, _>()
}
async fn delete_agent(
&self,
input: DeleteAgentRequest,
) -> Result<DeleteAgentResponse, RusotoError<DeleteAgentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.DeleteAgent");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteAgentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteAgentResponse, _>()
}
async fn delete_location(
&self,
input: DeleteLocationRequest,
) -> Result<DeleteLocationResponse, RusotoError<DeleteLocationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.DeleteLocation");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteLocationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteLocationResponse, _>()
}
async fn delete_task(
&self,
input: DeleteTaskRequest,
) -> Result<DeleteTaskResponse, RusotoError<DeleteTaskError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.DeleteTask");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteTaskError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteTaskResponse, _>()
}
async fn describe_agent(
&self,
input: DescribeAgentRequest,
) -> Result<DescribeAgentResponse, RusotoError<DescribeAgentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.DescribeAgent");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeAgentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeAgentResponse, _>()
}
async fn describe_location_efs(
&self,
input: DescribeLocationEfsRequest,
) -> Result<DescribeLocationEfsResponse, RusotoError<DescribeLocationEfsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.DescribeLocationEfs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeLocationEfsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeLocationEfsResponse, _>()
}
async fn describe_location_fsx_windows(
&self,
input: DescribeLocationFsxWindowsRequest,
) -> Result<DescribeLocationFsxWindowsResponse, RusotoError<DescribeLocationFsxWindowsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.DescribeLocationFsxWindows");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeLocationFsxWindowsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeLocationFsxWindowsResponse, _>()
}
async fn describe_location_nfs(
&self,
input: DescribeLocationNfsRequest,
) -> Result<DescribeLocationNfsResponse, RusotoError<DescribeLocationNfsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.DescribeLocationNfs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeLocationNfsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeLocationNfsResponse, _>()
}
async fn describe_location_s3(
&self,
input: DescribeLocationS3Request,
) -> Result<DescribeLocationS3Response, RusotoError<DescribeLocationS3Error>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.DescribeLocationS3");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeLocationS3Error::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeLocationS3Response, _>()
}
async fn describe_location_smb(
&self,
input: DescribeLocationSmbRequest,
) -> Result<DescribeLocationSmbResponse, RusotoError<DescribeLocationSmbError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.DescribeLocationSmb");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeLocationSmbError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeLocationSmbResponse, _>()
}
async fn describe_task(
&self,
input: DescribeTaskRequest,
) -> Result<DescribeTaskResponse, RusotoError<DescribeTaskError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.DescribeTask");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeTaskError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeTaskResponse, _>()
}
async fn describe_task_execution(
&self,
input: DescribeTaskExecutionRequest,
) -> Result<DescribeTaskExecutionResponse, RusotoError<DescribeTaskExecutionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.DescribeTaskExecution");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeTaskExecutionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeTaskExecutionResponse, _>()
}
async fn list_agents(
&self,
input: ListAgentsRequest,
) -> Result<ListAgentsResponse, RusotoError<ListAgentsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.ListAgents");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListAgentsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListAgentsResponse, _>()
}
async fn list_locations(
&self,
input: ListLocationsRequest,
) -> Result<ListLocationsResponse, RusotoError<ListLocationsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.ListLocations");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListLocationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListLocationsResponse, _>()
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.ListTagsForResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceResponse, _>()
}
async fn list_task_executions(
&self,
input: ListTaskExecutionsRequest,
) -> Result<ListTaskExecutionsResponse, RusotoError<ListTaskExecutionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.ListTaskExecutions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTaskExecutionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTaskExecutionsResponse, _>()
}
async fn list_tasks(
&self,
input: ListTasksRequest,
) -> Result<ListTasksResponse, RusotoError<ListTasksError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.ListTasks");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTasksError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTasksResponse, _>()
}
async fn start_task_execution(
&self,
input: StartTaskExecutionRequest,
) -> Result<StartTaskExecutionResponse, RusotoError<StartTaskExecutionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.StartTaskExecution");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartTaskExecutionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StartTaskExecutionResponse, _>()
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceResponse, _>()
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceResponse, _>()
}
async fn update_agent(
&self,
input: UpdateAgentRequest,
) -> Result<UpdateAgentResponse, RusotoError<UpdateAgentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.UpdateAgent");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateAgentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateAgentResponse, _>()
}
async fn update_task(
&self,
input: UpdateTaskRequest,
) -> Result<UpdateTaskResponse, RusotoError<UpdateTaskError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "FmrsService.UpdateTask");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateTaskError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateTaskResponse, _>()
}
}