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 ApplicationInsightsClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(
http_method,
"applicationinsights",
&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 ApplicationComponent {
#[serde(rename = "ComponentName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub component_name: Option<String>,
#[serde(rename = "Monitor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monitor: Option<bool>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "Tier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tier: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApplicationInfo {
#[serde(rename = "CWEMonitorEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cwe_monitor_enabled: Option<bool>,
#[serde(rename = "LifeCycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub life_cycle: Option<String>,
#[serde(rename = "OpsCenterEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ops_center_enabled: Option<bool>,
#[serde(rename = "OpsItemSNSTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ops_item_sns_topic_arn: Option<String>,
#[serde(rename = "Remarks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remarks: Option<String>,
#[serde(rename = "ResourceGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_group_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfigurationEvent {
#[serde(rename = "EventDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_detail: Option<String>,
#[serde(rename = "EventResourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_resource_name: Option<String>,
#[serde(rename = "EventResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_resource_type: Option<String>,
#[serde(rename = "EventStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_status: Option<String>,
#[serde(rename = "EventTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_time: Option<f64>,
#[serde(rename = "MonitoredResourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monitored_resource_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateApplicationRequest {
#[serde(rename = "CWEMonitorEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cwe_monitor_enabled: Option<bool>,
#[serde(rename = "OpsCenterEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ops_center_enabled: Option<bool>,
#[serde(rename = "OpsItemSNSTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ops_item_sns_topic_arn: Option<String>,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: 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 CreateApplicationResponse {
#[serde(rename = "ApplicationInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_info: Option<ApplicationInfo>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateComponentRequest {
#[serde(rename = "ComponentName")]
pub component_name: String,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
#[serde(rename = "ResourceList")]
pub resource_list: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateComponentResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLogPatternRequest {
#[serde(rename = "Pattern")]
pub pattern: String,
#[serde(rename = "PatternName")]
pub pattern_name: String,
#[serde(rename = "PatternSetName")]
pub pattern_set_name: String,
#[serde(rename = "Rank")]
pub rank: i64,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLogPatternResponse {
#[serde(rename = "LogPattern")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_pattern: Option<LogPattern>,
#[serde(rename = "ResourceGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_group_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApplicationRequest {
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteApplicationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteComponentRequest {
#[serde(rename = "ComponentName")]
pub component_name: String,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteComponentResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteLogPatternRequest {
#[serde(rename = "PatternName")]
pub pattern_name: String,
#[serde(rename = "PatternSetName")]
pub pattern_set_name: String,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteLogPatternResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeApplicationRequest {
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeApplicationResponse {
#[serde(rename = "ApplicationInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_info: Option<ApplicationInfo>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeComponentConfigurationRecommendationRequest {
#[serde(rename = "ComponentName")]
pub component_name: String,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
#[serde(rename = "Tier")]
pub tier: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeComponentConfigurationRecommendationResponse {
#[serde(rename = "ComponentConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub component_configuration: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeComponentConfigurationRequest {
#[serde(rename = "ComponentName")]
pub component_name: String,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeComponentConfigurationResponse {
#[serde(rename = "ComponentConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub component_configuration: Option<String>,
#[serde(rename = "Monitor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monitor: Option<bool>,
#[serde(rename = "Tier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeComponentRequest {
#[serde(rename = "ComponentName")]
pub component_name: String,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeComponentResponse {
#[serde(rename = "ApplicationComponent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_component: Option<ApplicationComponent>,
#[serde(rename = "ResourceList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_list: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeLogPatternRequest {
#[serde(rename = "PatternName")]
pub pattern_name: String,
#[serde(rename = "PatternSetName")]
pub pattern_set_name: String,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeLogPatternResponse {
#[serde(rename = "LogPattern")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_pattern: Option<LogPattern>,
#[serde(rename = "ResourceGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_group_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeObservationRequest {
#[serde(rename = "ObservationId")]
pub observation_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeObservationResponse {
#[serde(rename = "Observation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub observation: Option<Observation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeProblemObservationsRequest {
#[serde(rename = "ProblemId")]
pub problem_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeProblemObservationsResponse {
#[serde(rename = "RelatedObservations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub related_observations: Option<RelatedObservations>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeProblemRequest {
#[serde(rename = "ProblemId")]
pub problem_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeProblemResponse {
#[serde(rename = "Problem")]
#[serde(skip_serializing_if = "Option::is_none")]
pub problem: Option<Problem>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListApplicationsRequest {
#[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 ListApplicationsResponse {
#[serde(rename = "ApplicationInfoList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_info_list: Option<Vec<ApplicationInfo>>,
#[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 ListComponentsRequest {
#[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 = "ResourceGroupName")]
pub resource_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListComponentsResponse {
#[serde(rename = "ApplicationComponentList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_component_list: Option<Vec<ApplicationComponent>>,
#[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 ListConfigurationHistoryRequest {
#[serde(rename = "EndTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "EventStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_status: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_group_name: Option<String>,
#[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 ListConfigurationHistoryResponse {
#[serde(rename = "EventList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_list: Option<Vec<ConfigurationEvent>>,
#[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 ListLogPatternSetsRequest {
#[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 = "ResourceGroupName")]
pub resource_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListLogPatternSetsResponse {
#[serde(rename = "LogPatternSets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_pattern_sets: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_group_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListLogPatternsRequest {
#[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 = "PatternSetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pattern_set_name: Option<String>,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListLogPatternsResponse {
#[serde(rename = "LogPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_patterns: Option<Vec<LogPattern>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_group_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListProblemsRequest {
#[serde(rename = "EndTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[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 = "ResourceGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_group_name: Option<String>,
#[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 ListProblemsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ProblemList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub problem_list: Option<Vec<Problem>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[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 = "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 LogPattern {
#[serde(rename = "Pattern")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pattern: Option<String>,
#[serde(rename = "PatternName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pattern_name: Option<String>,
#[serde(rename = "PatternSetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pattern_set_name: Option<String>,
#[serde(rename = "Rank")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rank: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Observation {
#[serde(rename = "CloudWatchEventDetailType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_event_detail_type: Option<String>,
#[serde(rename = "CloudWatchEventId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_event_id: Option<String>,
#[serde(rename = "CloudWatchEventSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_event_source: Option<String>,
#[serde(rename = "CodeDeployApplication")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_deploy_application: Option<String>,
#[serde(rename = "CodeDeployDeploymentGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_deploy_deployment_group: Option<String>,
#[serde(rename = "CodeDeployDeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_deploy_deployment_id: Option<String>,
#[serde(rename = "CodeDeployInstanceGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_deploy_instance_group_id: Option<String>,
#[serde(rename = "CodeDeployState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_deploy_state: Option<String>,
#[serde(rename = "Ec2State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_state: Option<String>,
#[serde(rename = "EndTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "HealthEventArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_event_arn: Option<String>,
#[serde(rename = "HealthEventDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_event_description: Option<String>,
#[serde(rename = "HealthEventTypeCategory")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_event_type_category: Option<String>,
#[serde(rename = "HealthEventTypeCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_event_type_code: Option<String>,
#[serde(rename = "HealthService")]
#[serde(skip_serializing_if = "Option::is_none")]
pub health_service: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LineTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub line_time: Option<f64>,
#[serde(rename = "LogFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_filter: Option<String>,
#[serde(rename = "LogGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_group: Option<String>,
#[serde(rename = "LogText")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_text: Option<String>,
#[serde(rename = "MetricName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_name: Option<String>,
#[serde(rename = "MetricNamespace")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_namespace: Option<String>,
#[serde(rename = "SourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_arn: Option<String>,
#[serde(rename = "SourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_type: Option<String>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "Unit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unit: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<f64>,
#[serde(rename = "XRayErrorPercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub x_ray_error_percent: Option<i64>,
#[serde(rename = "XRayFaultPercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub x_ray_fault_percent: Option<i64>,
#[serde(rename = "XRayNodeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub x_ray_node_name: Option<String>,
#[serde(rename = "XRayNodeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub x_ray_node_type: Option<String>,
#[serde(rename = "XRayRequestAverageLatency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub x_ray_request_average_latency: Option<i64>,
#[serde(rename = "XRayRequestCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub x_ray_request_count: Option<i64>,
#[serde(rename = "XRayThrottlePercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub x_ray_throttle_percent: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Problem {
#[serde(rename = "AffectedResource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub affected_resource: Option<String>,
#[serde(rename = "EndTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "Feedback")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feedback: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Insights")]
#[serde(skip_serializing_if = "Option::is_none")]
pub insights: Option<String>,
#[serde(rename = "ResourceGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_group_name: Option<String>,
#[serde(rename = "SeverityLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub severity_level: Option<String>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Title")]
#[serde(skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RelatedObservations {
#[serde(rename = "ObservationList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub observation_list: Option<Vec<Observation>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
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 TagResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: 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 TagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<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 UpdateApplicationRequest {
#[serde(rename = "CWEMonitorEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cwe_monitor_enabled: Option<bool>,
#[serde(rename = "OpsCenterEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ops_center_enabled: Option<bool>,
#[serde(rename = "OpsItemSNSTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ops_item_sns_topic_arn: Option<String>,
#[serde(rename = "RemoveSNSTopic")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remove_sns_topic: Option<bool>,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateApplicationResponse {
#[serde(rename = "ApplicationInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_info: Option<ApplicationInfo>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateComponentConfigurationRequest {
#[serde(rename = "ComponentConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub component_configuration: Option<String>,
#[serde(rename = "ComponentName")]
pub component_name: String,
#[serde(rename = "Monitor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monitor: Option<bool>,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
#[serde(rename = "Tier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tier: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateComponentConfigurationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateComponentRequest {
#[serde(rename = "ComponentName")]
pub component_name: String,
#[serde(rename = "NewComponentName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub new_component_name: Option<String>,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
#[serde(rename = "ResourceList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_list: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateComponentResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateLogPatternRequest {
#[serde(rename = "Pattern")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pattern: Option<String>,
#[serde(rename = "PatternName")]
pub pattern_name: String,
#[serde(rename = "PatternSetName")]
pub pattern_set_name: String,
#[serde(rename = "Rank")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rank: Option<i64>,
#[serde(rename = "ResourceGroupName")]
pub resource_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateLogPatternResponse {
#[serde(rename = "LogPattern")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_pattern: Option<LogPattern>,
#[serde(rename = "ResourceGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_group_name: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum CreateApplicationError {
InternalServer(String),
ResourceInUse(String),
ResourceNotFound(String),
TagsAlreadyExist(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() {
"InternalServerException" => {
return RusotoError::Service(CreateApplicationError::InternalServer(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateApplicationError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateApplicationError::ResourceNotFound(err.msg))
}
"TagsAlreadyExistException" => {
return RusotoError::Service(CreateApplicationError::TagsAlreadyExist(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::InternalServer(ref cause) => write!(f, "{}", cause),
CreateApplicationError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateApplicationError::TagsAlreadyExist(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateApplicationError {}
#[derive(Debug, PartialEq)]
pub enum CreateComponentError {
InternalServer(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl CreateComponentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateComponentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(CreateComponentError::InternalServer(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateComponentError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateComponentError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateComponentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateComponentError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateComponentError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateComponentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateComponentError {}
#[derive(Debug, PartialEq)]
pub enum CreateLogPatternError {
InternalServer(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl CreateLogPatternError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLogPatternError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(CreateLogPatternError::InternalServer(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateLogPatternError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateLogPatternError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLogPatternError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLogPatternError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateLogPatternError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateLogPatternError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLogPatternError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl DeleteApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteApplicationError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DeleteApplicationError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteApplicationError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApplicationError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteApplicationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteComponentError {
InternalServer(String),
ResourceNotFound(String),
}
impl DeleteComponentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteComponentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DeleteComponentError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteComponentError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteComponentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteComponentError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteComponentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteComponentError {}
#[derive(Debug, PartialEq)]
pub enum DeleteLogPatternError {
BadRequest(String),
InternalServer(String),
ResourceNotFound(String),
}
impl DeleteLogPatternError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteLogPatternError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteLogPatternError::BadRequest(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DeleteLogPatternError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteLogPatternError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLogPatternError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLogPatternError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteLogPatternError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteLogPatternError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteLogPatternError {}
#[derive(Debug, PartialEq)]
pub enum DescribeApplicationError {
InternalServer(String),
ResourceNotFound(String),
}
impl DescribeApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeApplicationError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeApplicationError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeApplicationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeComponentError {
InternalServer(String),
ResourceNotFound(String),
}
impl DescribeComponentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeComponentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeComponentError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeComponentError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeComponentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeComponentError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeComponentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeComponentError {}
#[derive(Debug, PartialEq)]
pub enum DescribeComponentConfigurationError {
InternalServer(String),
ResourceNotFound(String),
}
impl DescribeComponentConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeComponentConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(
DescribeComponentConfigurationError::InternalServer(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeComponentConfigurationError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeComponentConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeComponentConfigurationError::InternalServer(ref cause) => {
write!(f, "{}", cause)
}
DescribeComponentConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeComponentConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeComponentConfigurationRecommendationError {
InternalServer(String),
ResourceNotFound(String),
}
impl DescribeComponentConfigurationRecommendationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeComponentConfigurationRecommendationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(
DescribeComponentConfigurationRecommendationError::InternalServer(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeComponentConfigurationRecommendationError::ResourceNotFound(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeComponentConfigurationRecommendationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeComponentConfigurationRecommendationError::InternalServer(ref cause) => {
write!(f, "{}", cause)
}
DescribeComponentConfigurationRecommendationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeComponentConfigurationRecommendationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeLogPatternError {
InternalServer(String),
ResourceNotFound(String),
}
impl DescribeLogPatternError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLogPatternError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeLogPatternError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeLogPatternError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeLogPatternError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLogPatternError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeLogPatternError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLogPatternError {}
#[derive(Debug, PartialEq)]
pub enum DescribeObservationError {
InternalServer(String),
ResourceNotFound(String),
}
impl DescribeObservationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeObservationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeObservationError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeObservationError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeObservationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeObservationError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeObservationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeObservationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeProblemError {
InternalServer(String),
ResourceNotFound(String),
}
impl DescribeProblemError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeProblemError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeProblemError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeProblemError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeProblemError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeProblemError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeProblemError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeProblemError {}
#[derive(Debug, PartialEq)]
pub enum DescribeProblemObservationsError {
InternalServer(String),
ResourceNotFound(String),
}
impl DescribeProblemObservationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeProblemObservationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeProblemObservationsError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeProblemObservationsError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeProblemObservationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeProblemObservationsError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeProblemObservationsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeProblemObservationsError {}
#[derive(Debug, PartialEq)]
pub enum ListApplicationsError {
InternalServer(String),
}
impl ListApplicationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListApplicationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListApplicationsError::InternalServer(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListApplicationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListApplicationsError::InternalServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListApplicationsError {}
#[derive(Debug, PartialEq)]
pub enum ListComponentsError {
InternalServer(String),
ResourceNotFound(String),
}
impl ListComponentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListComponentsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListComponentsError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListComponentsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListComponentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListComponentsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListComponentsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListComponentsError {}
#[derive(Debug, PartialEq)]
pub enum ListConfigurationHistoryError {
InternalServer(String),
ResourceNotFound(String),
}
impl ListConfigurationHistoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListConfigurationHistoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListConfigurationHistoryError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListConfigurationHistoryError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListConfigurationHistoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListConfigurationHistoryError::InternalServer(ref cause) => write!(f, "{}", cause),
ListConfigurationHistoryError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListConfigurationHistoryError {}
#[derive(Debug, PartialEq)]
pub enum ListLogPatternSetsError {
InternalServer(String),
ResourceNotFound(String),
}
impl ListLogPatternSetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLogPatternSetsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListLogPatternSetsError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListLogPatternSetsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLogPatternSetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLogPatternSetsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListLogPatternSetsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLogPatternSetsError {}
#[derive(Debug, PartialEq)]
pub enum ListLogPatternsError {
InternalServer(String),
ResourceNotFound(String),
}
impl ListLogPatternsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLogPatternsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListLogPatternsError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListLogPatternsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLogPatternsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLogPatternsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListLogPatternsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLogPatternsError {}
#[derive(Debug, PartialEq)]
pub enum ListProblemsError {
InternalServer(String),
ResourceNotFound(String),
}
impl ListProblemsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListProblemsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListProblemsError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListProblemsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListProblemsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListProblemsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListProblemsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListProblemsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
ResourceNotFound(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() {
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
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::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
ResourceNotFound(String),
TooManyTags(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() {
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"TooManyTagsException" => {
return RusotoError::Service(TagResourceError::TooManyTags(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::ResourceNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
ResourceNotFound(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() {
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(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::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateApplicationError {
InternalServer(String),
ResourceNotFound(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() {
"InternalServerException" => {
return RusotoError::Service(UpdateApplicationError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateApplicationError::ResourceNotFound(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::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateApplicationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateComponentError {
InternalServer(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl UpdateComponentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateComponentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(UpdateComponentError::InternalServer(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(UpdateComponentError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateComponentError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateComponentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateComponentError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateComponentError::ResourceInUse(ref cause) => write!(f, "{}", cause),
UpdateComponentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateComponentError {}
#[derive(Debug, PartialEq)]
pub enum UpdateComponentConfigurationError {
InternalServer(String),
ResourceNotFound(String),
}
impl UpdateComponentConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateComponentConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(UpdateComponentConfigurationError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
UpdateComponentConfigurationError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateComponentConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateComponentConfigurationError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateComponentConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateComponentConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateLogPatternError {
InternalServer(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl UpdateLogPatternError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateLogPatternError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(UpdateLogPatternError::InternalServer(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(UpdateLogPatternError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateLogPatternError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateLogPatternError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateLogPatternError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateLogPatternError::ResourceInUse(ref cause) => write!(f, "{}", cause),
UpdateLogPatternError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateLogPatternError {}
#[async_trait]
pub trait ApplicationInsights {
async fn create_application(
&self,
input: CreateApplicationRequest,
) -> Result<CreateApplicationResponse, RusotoError<CreateApplicationError>>;
async fn create_component(
&self,
input: CreateComponentRequest,
) -> Result<CreateComponentResponse, RusotoError<CreateComponentError>>;
async fn create_log_pattern(
&self,
input: CreateLogPatternRequest,
) -> Result<CreateLogPatternResponse, RusotoError<CreateLogPatternError>>;
async fn delete_application(
&self,
input: DeleteApplicationRequest,
) -> Result<DeleteApplicationResponse, RusotoError<DeleteApplicationError>>;
async fn delete_component(
&self,
input: DeleteComponentRequest,
) -> Result<DeleteComponentResponse, RusotoError<DeleteComponentError>>;
async fn delete_log_pattern(
&self,
input: DeleteLogPatternRequest,
) -> Result<DeleteLogPatternResponse, RusotoError<DeleteLogPatternError>>;
async fn describe_application(
&self,
input: DescribeApplicationRequest,
) -> Result<DescribeApplicationResponse, RusotoError<DescribeApplicationError>>;
async fn describe_component(
&self,
input: DescribeComponentRequest,
) -> Result<DescribeComponentResponse, RusotoError<DescribeComponentError>>;
async fn describe_component_configuration(
&self,
input: DescribeComponentConfigurationRequest,
) -> Result<
DescribeComponentConfigurationResponse,
RusotoError<DescribeComponentConfigurationError>,
>;
async fn describe_component_configuration_recommendation(
&self,
input: DescribeComponentConfigurationRecommendationRequest,
) -> Result<
DescribeComponentConfigurationRecommendationResponse,
RusotoError<DescribeComponentConfigurationRecommendationError>,
>;
async fn describe_log_pattern(
&self,
input: DescribeLogPatternRequest,
) -> Result<DescribeLogPatternResponse, RusotoError<DescribeLogPatternError>>;
async fn describe_observation(
&self,
input: DescribeObservationRequest,
) -> Result<DescribeObservationResponse, RusotoError<DescribeObservationError>>;
async fn describe_problem(
&self,
input: DescribeProblemRequest,
) -> Result<DescribeProblemResponse, RusotoError<DescribeProblemError>>;
async fn describe_problem_observations(
&self,
input: DescribeProblemObservationsRequest,
) -> Result<DescribeProblemObservationsResponse, RusotoError<DescribeProblemObservationsError>>;
async fn list_applications(
&self,
input: ListApplicationsRequest,
) -> Result<ListApplicationsResponse, RusotoError<ListApplicationsError>>;
async fn list_components(
&self,
input: ListComponentsRequest,
) -> Result<ListComponentsResponse, RusotoError<ListComponentsError>>;
async fn list_configuration_history(
&self,
input: ListConfigurationHistoryRequest,
) -> Result<ListConfigurationHistoryResponse, RusotoError<ListConfigurationHistoryError>>;
async fn list_log_pattern_sets(
&self,
input: ListLogPatternSetsRequest,
) -> Result<ListLogPatternSetsResponse, RusotoError<ListLogPatternSetsError>>;
async fn list_log_patterns(
&self,
input: ListLogPatternsRequest,
) -> Result<ListLogPatternsResponse, RusotoError<ListLogPatternsError>>;
async fn list_problems(
&self,
input: ListProblemsRequest,
) -> Result<ListProblemsResponse, RusotoError<ListProblemsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
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_application(
&self,
input: UpdateApplicationRequest,
) -> Result<UpdateApplicationResponse, RusotoError<UpdateApplicationError>>;
async fn update_component(
&self,
input: UpdateComponentRequest,
) -> Result<UpdateComponentResponse, RusotoError<UpdateComponentError>>;
async fn update_component_configuration(
&self,
input: UpdateComponentConfigurationRequest,
) -> Result<UpdateComponentConfigurationResponse, RusotoError<UpdateComponentConfigurationError>>;
async fn update_log_pattern(
&self,
input: UpdateLogPatternRequest,
) -> Result<UpdateLogPatternResponse, RusotoError<UpdateLogPatternError>>;
}
#[derive(Clone)]
pub struct ApplicationInsightsClient {
client: Client,
region: region::Region,
}
impl ApplicationInsightsClient {
pub fn new(region: region::Region) -> ApplicationInsightsClient {
ApplicationInsightsClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ApplicationInsightsClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ApplicationInsightsClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ApplicationInsightsClient {
ApplicationInsightsClient { client, region }
}
}
#[async_trait]
impl ApplicationInsights for ApplicationInsightsClient {
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", "EC2WindowsBarleyService.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_component(
&self,
input: CreateComponentRequest,
) -> Result<CreateComponentResponse, RusotoError<CreateComponentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.CreateComponent");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateComponentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateComponentResponse, _>()
}
async fn create_log_pattern(
&self,
input: CreateLogPatternRequest,
) -> Result<CreateLogPatternResponse, RusotoError<CreateLogPatternError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.CreateLogPattern");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateLogPatternError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateLogPatternResponse, _>()
}
async fn delete_application(
&self,
input: DeleteApplicationRequest,
) -> Result<DeleteApplicationResponse, RusotoError<DeleteApplicationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.DeleteApplication");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteApplicationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteApplicationResponse, _>()
}
async fn delete_component(
&self,
input: DeleteComponentRequest,
) -> Result<DeleteComponentResponse, RusotoError<DeleteComponentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.DeleteComponent");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteComponentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteComponentResponse, _>()
}
async fn delete_log_pattern(
&self,
input: DeleteLogPatternRequest,
) -> Result<DeleteLogPatternResponse, RusotoError<DeleteLogPatternError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.DeleteLogPattern");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteLogPatternError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteLogPatternResponse, _>()
}
async fn describe_application(
&self,
input: DescribeApplicationRequest,
) -> Result<DescribeApplicationResponse, RusotoError<DescribeApplicationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"EC2WindowsBarleyService.DescribeApplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeApplicationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeApplicationResponse, _>()
}
async fn describe_component(
&self,
input: DescribeComponentRequest,
) -> Result<DescribeComponentResponse, RusotoError<DescribeComponentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.DescribeComponent");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeComponentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeComponentResponse, _>()
}
async fn describe_component_configuration(
&self,
input: DescribeComponentConfigurationRequest,
) -> Result<
DescribeComponentConfigurationResponse,
RusotoError<DescribeComponentConfigurationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"EC2WindowsBarleyService.DescribeComponentConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeComponentConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeComponentConfigurationResponse, _>()
}
async fn describe_component_configuration_recommendation(
&self,
input: DescribeComponentConfigurationRecommendationRequest,
) -> Result<
DescribeComponentConfigurationRecommendationResponse,
RusotoError<DescribeComponentConfigurationRecommendationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"EC2WindowsBarleyService.DescribeComponentConfigurationRecommendation",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeComponentConfigurationRecommendationError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeComponentConfigurationRecommendationResponse, _>()
}
async fn describe_log_pattern(
&self,
input: DescribeLogPatternRequest,
) -> Result<DescribeLogPatternResponse, RusotoError<DescribeLogPatternError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.DescribeLogPattern");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeLogPatternError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeLogPatternResponse, _>()
}
async fn describe_observation(
&self,
input: DescribeObservationRequest,
) -> Result<DescribeObservationResponse, RusotoError<DescribeObservationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"EC2WindowsBarleyService.DescribeObservation",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeObservationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeObservationResponse, _>()
}
async fn describe_problem(
&self,
input: DescribeProblemRequest,
) -> Result<DescribeProblemResponse, RusotoError<DescribeProblemError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.DescribeProblem");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeProblemError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeProblemResponse, _>()
}
async fn describe_problem_observations(
&self,
input: DescribeProblemObservationsRequest,
) -> Result<DescribeProblemObservationsResponse, RusotoError<DescribeProblemObservationsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"EC2WindowsBarleyService.DescribeProblemObservations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeProblemObservationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeProblemObservationsResponse, _>()
}
async fn list_applications(
&self,
input: ListApplicationsRequest,
) -> Result<ListApplicationsResponse, RusotoError<ListApplicationsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.ListApplications");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListApplicationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListApplicationsResponse, _>()
}
async fn list_components(
&self,
input: ListComponentsRequest,
) -> Result<ListComponentsResponse, RusotoError<ListComponentsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.ListComponents");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListComponentsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListComponentsResponse, _>()
}
async fn list_configuration_history(
&self,
input: ListConfigurationHistoryRequest,
) -> Result<ListConfigurationHistoryResponse, RusotoError<ListConfigurationHistoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"EC2WindowsBarleyService.ListConfigurationHistory",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListConfigurationHistoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListConfigurationHistoryResponse, _>()
}
async fn list_log_pattern_sets(
&self,
input: ListLogPatternSetsRequest,
) -> Result<ListLogPatternSetsResponse, RusotoError<ListLogPatternSetsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.ListLogPatternSets");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListLogPatternSetsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListLogPatternSetsResponse, _>()
}
async fn list_log_patterns(
&self,
input: ListLogPatternsRequest,
) -> Result<ListLogPatternsResponse, RusotoError<ListLogPatternsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.ListLogPatterns");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListLogPatternsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListLogPatternsResponse, _>()
}
async fn list_problems(
&self,
input: ListProblemsRequest,
) -> Result<ListProblemsResponse, RusotoError<ListProblemsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.ListProblems");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListProblemsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListProblemsResponse, _>()
}
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",
"EC2WindowsBarleyService.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 tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.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", "EC2WindowsBarleyService.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_application(
&self,
input: UpdateApplicationRequest,
) -> Result<UpdateApplicationResponse, RusotoError<UpdateApplicationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.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, _>()
}
async fn update_component(
&self,
input: UpdateComponentRequest,
) -> Result<UpdateComponentResponse, RusotoError<UpdateComponentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.UpdateComponent");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateComponentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateComponentResponse, _>()
}
async fn update_component_configuration(
&self,
input: UpdateComponentConfigurationRequest,
) -> Result<UpdateComponentConfigurationResponse, RusotoError<UpdateComponentConfigurationError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"EC2WindowsBarleyService.UpdateComponentConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateComponentConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateComponentConfigurationResponse, _>()
}
async fn update_log_pattern(
&self,
input: UpdateLogPatternRequest,
) -> Result<UpdateLogPatternResponse, RusotoError<UpdateLogPatternError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "EC2WindowsBarleyService.UpdateLogPattern");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateLogPatternError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateLogPatternResponse, _>()
}
}