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::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ApprovalThresholdPolicy {
#[serde(rename = "ProposalDurationInHours")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposal_duration_in_hours: Option<i64>,
#[serde(rename = "ThresholdComparator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub threshold_comparator: Option<String>,
#[serde(rename = "ThresholdPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub threshold_percentage: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateMemberInput {
#[serde(rename = "ClientRequestToken")]
pub client_request_token: String,
#[serde(rename = "InvitationId")]
pub invitation_id: String,
#[serde(rename = "MemberConfiguration")]
pub member_configuration: MemberConfiguration,
#[serde(rename = "NetworkId")]
pub network_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateMemberOutput {
#[serde(rename = "MemberId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub member_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateNetworkInput {
#[serde(rename = "ClientRequestToken")]
pub client_request_token: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Framework")]
pub framework: String,
#[serde(rename = "FrameworkConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framework_configuration: Option<NetworkFrameworkConfiguration>,
#[serde(rename = "FrameworkVersion")]
pub framework_version: String,
#[serde(rename = "MemberConfiguration")]
pub member_configuration: MemberConfiguration,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "VotingPolicy")]
pub voting_policy: VotingPolicy,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateNetworkOutput {
#[serde(rename = "MemberId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub member_id: Option<String>,
#[serde(rename = "NetworkId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateNodeInput {
#[serde(rename = "ClientRequestToken")]
pub client_request_token: String,
#[serde(rename = "MemberId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub member_id: Option<String>,
#[serde(rename = "NetworkId")]
pub network_id: String,
#[serde(rename = "NodeConfiguration")]
pub node_configuration: NodeConfiguration,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateNodeOutput {
#[serde(rename = "NodeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub node_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateProposalInput {
#[serde(rename = "Actions")]
pub actions: ProposalActions,
#[serde(rename = "ClientRequestToken")]
pub client_request_token: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "MemberId")]
pub member_id: String,
#[serde(rename = "NetworkId")]
pub network_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateProposalOutput {
#[serde(rename = "ProposalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposal_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteMemberInput {
#[serde(rename = "MemberId")]
pub member_id: String,
#[serde(rename = "NetworkId")]
pub network_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteMemberOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteNodeInput {
#[serde(rename = "MemberId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub member_id: Option<String>,
#[serde(rename = "NetworkId")]
pub network_id: String,
#[serde(rename = "NodeId")]
pub node_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteNodeOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetMemberInput {
#[serde(rename = "MemberId")]
pub member_id: String,
#[serde(rename = "NetworkId")]
pub network_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetMemberOutput {
#[serde(rename = "Member")]
#[serde(skip_serializing_if = "Option::is_none")]
pub member: Option<Member>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetNetworkInput {
#[serde(rename = "NetworkId")]
pub network_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetNetworkOutput {
#[serde(rename = "Network")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network: Option<Network>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetNodeInput {
#[serde(rename = "MemberId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub member_id: Option<String>,
#[serde(rename = "NetworkId")]
pub network_id: String,
#[serde(rename = "NodeId")]
pub node_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetNodeOutput {
#[serde(rename = "Node")]
#[serde(skip_serializing_if = "Option::is_none")]
pub node: Option<Node>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetProposalInput {
#[serde(rename = "NetworkId")]
pub network_id: String,
#[serde(rename = "ProposalId")]
pub proposal_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetProposalOutput {
#[serde(rename = "Proposal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposal: Option<Proposal>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Invitation {
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "ExpirationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration_date: Option<f64>,
#[serde(rename = "InvitationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invitation_id: Option<String>,
#[serde(rename = "NetworkSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_summary: Option<NetworkSummary>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct InviteAction {
#[serde(rename = "Principal")]
pub principal: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListInvitationsInput {
#[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 ListInvitationsOutput {
#[serde(rename = "Invitations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invitations: Option<Vec<Invitation>>,
#[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 ListMembersInput {
#[serde(rename = "IsOwned")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_owned: Option<bool>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "NetworkId")]
pub network_id: String,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListMembersOutput {
#[serde(rename = "Members")]
#[serde(skip_serializing_if = "Option::is_none")]
pub members: Option<Vec<MemberSummary>>,
#[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 ListNetworksInput {
#[serde(rename = "Framework")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framework: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListNetworksOutput {
#[serde(rename = "Networks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub networks: Option<Vec<NetworkSummary>>,
#[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 ListNodesInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "MemberId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub member_id: Option<String>,
#[serde(rename = "NetworkId")]
pub network_id: String,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListNodesOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Nodes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub nodes: Option<Vec<NodeSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListProposalVotesInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NetworkId")]
pub network_id: String,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ProposalId")]
pub proposal_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListProposalVotesOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ProposalVotes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposal_votes: Option<Vec<VoteSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListProposalsInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NetworkId")]
pub network_id: String,
#[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 ListProposalsOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Proposals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposals: Option<Vec<ProposalSummary>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LogConfiguration {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LogConfigurations {
#[serde(rename = "Cloudwatch")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloudwatch: Option<LogConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Member {
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "FrameworkAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framework_attributes: Option<MemberFrameworkAttributes>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LogPublishingConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_publishing_configuration: Option<MemberLogPublishingConfiguration>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "NetworkId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_id: 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 MemberConfiguration {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "FrameworkConfiguration")]
pub framework_configuration: MemberFrameworkConfiguration,
#[serde(rename = "LogPublishingConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_publishing_configuration: Option<MemberLogPublishingConfiguration>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MemberFabricAttributes {
#[serde(rename = "AdminUsername")]
#[serde(skip_serializing_if = "Option::is_none")]
pub admin_username: Option<String>,
#[serde(rename = "CaEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ca_endpoint: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MemberFabricConfiguration {
#[serde(rename = "AdminPassword")]
pub admin_password: String,
#[serde(rename = "AdminUsername")]
pub admin_username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MemberFabricLogPublishingConfiguration {
#[serde(rename = "CaLogs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ca_logs: Option<LogConfigurations>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MemberFrameworkAttributes {
#[serde(rename = "Fabric")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fabric: Option<MemberFabricAttributes>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MemberFrameworkConfiguration {
#[serde(rename = "Fabric")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fabric: Option<MemberFabricConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MemberLogPublishingConfiguration {
#[serde(rename = "Fabric")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fabric: Option<MemberFabricLogPublishingConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MemberSummary {
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "IsOwned")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_owned: Option<bool>,
#[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, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Network {
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Framework")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framework: Option<String>,
#[serde(rename = "FrameworkAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framework_attributes: Option<NetworkFrameworkAttributes>,
#[serde(rename = "FrameworkVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framework_version: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "VotingPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub voting_policy: Option<VotingPolicy>,
#[serde(rename = "VpcEndpointServiceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_endpoint_service_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NetworkEthereumAttributes {
#[serde(rename = "ChainId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub chain_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NetworkFabricAttributes {
#[serde(rename = "Edition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub edition: Option<String>,
#[serde(rename = "OrderingServiceEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ordering_service_endpoint: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NetworkFabricConfiguration {
#[serde(rename = "Edition")]
pub edition: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NetworkFrameworkAttributes {
#[serde(rename = "Ethereum")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ethereum: Option<NetworkEthereumAttributes>,
#[serde(rename = "Fabric")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fabric: Option<NetworkFabricAttributes>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NetworkFrameworkConfiguration {
#[serde(rename = "Fabric")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fabric: Option<NetworkFabricConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NetworkSummary {
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Framework")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framework: Option<String>,
#[serde(rename = "FrameworkVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framework_version: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Node {
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "FrameworkAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framework_attributes: Option<NodeFrameworkAttributes>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "InstanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type: Option<String>,
#[serde(rename = "LogPublishingConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_publishing_configuration: Option<NodeLogPublishingConfiguration>,
#[serde(rename = "MemberId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub member_id: Option<String>,
#[serde(rename = "NetworkId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_id: Option<String>,
#[serde(rename = "StateDB")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_db: 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 NodeConfiguration {
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "InstanceType")]
pub instance_type: String,
#[serde(rename = "LogPublishingConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_publishing_configuration: Option<NodeLogPublishingConfiguration>,
#[serde(rename = "StateDB")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_db: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NodeEthereumAttributes {
#[serde(rename = "HttpEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub http_endpoint: Option<String>,
#[serde(rename = "WebSocketEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub web_socket_endpoint: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NodeFabricAttributes {
#[serde(rename = "PeerEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub peer_endpoint: Option<String>,
#[serde(rename = "PeerEventEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub peer_event_endpoint: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct NodeFabricLogPublishingConfiguration {
#[serde(rename = "ChaincodeLogs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub chaincode_logs: Option<LogConfigurations>,
#[serde(rename = "PeerLogs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub peer_logs: Option<LogConfigurations>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NodeFrameworkAttributes {
#[serde(rename = "Ethereum")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ethereum: Option<NodeEthereumAttributes>,
#[serde(rename = "Fabric")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fabric: Option<NodeFabricAttributes>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct NodeLogPublishingConfiguration {
#[serde(rename = "Fabric")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fabric: Option<NodeFabricLogPublishingConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NodeSummary {
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "InstanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Proposal {
#[serde(rename = "Actions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub actions: Option<ProposalActions>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ExpirationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration_date: Option<f64>,
#[serde(rename = "NetworkId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_id: Option<String>,
#[serde(rename = "NoVoteCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub no_vote_count: Option<i64>,
#[serde(rename = "OutstandingVoteCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub outstanding_vote_count: Option<i64>,
#[serde(rename = "ProposalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposal_id: Option<String>,
#[serde(rename = "ProposedByMemberId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposed_by_member_id: Option<String>,
#[serde(rename = "ProposedByMemberName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposed_by_member_name: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "YesVoteCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub yes_vote_count: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProposalActions {
#[serde(rename = "Invitations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invitations: Option<Vec<InviteAction>>,
#[serde(rename = "Removals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub removals: Option<Vec<RemoveAction>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProposalSummary {
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ExpirationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration_date: Option<f64>,
#[serde(rename = "ProposalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposal_id: Option<String>,
#[serde(rename = "ProposedByMemberId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposed_by_member_id: Option<String>,
#[serde(rename = "ProposedByMemberName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposed_by_member_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 RejectInvitationInput {
#[serde(rename = "InvitationId")]
pub invitation_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RejectInvitationOutput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RemoveAction {
#[serde(rename = "MemberId")]
pub member_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateMemberInput {
#[serde(rename = "LogPublishingConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_publishing_configuration: Option<MemberLogPublishingConfiguration>,
#[serde(rename = "MemberId")]
pub member_id: String,
#[serde(rename = "NetworkId")]
pub network_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateMemberOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateNodeInput {
#[serde(rename = "LogPublishingConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_publishing_configuration: Option<NodeLogPublishingConfiguration>,
#[serde(rename = "MemberId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub member_id: Option<String>,
#[serde(rename = "NetworkId")]
pub network_id: String,
#[serde(rename = "NodeId")]
pub node_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateNodeOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct VoteOnProposalInput {
#[serde(rename = "NetworkId")]
pub network_id: String,
#[serde(rename = "ProposalId")]
pub proposal_id: String,
#[serde(rename = "Vote")]
pub vote: String,
#[serde(rename = "VoterMemberId")]
pub voter_member_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VoteOnProposalOutput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VoteSummary {
#[serde(rename = "MemberId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub member_id: Option<String>,
#[serde(rename = "MemberName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub member_name: Option<String>,
#[serde(rename = "Vote")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vote: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct VotingPolicy {
#[serde(rename = "ApprovalThresholdPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_threshold_policy: Option<ApprovalThresholdPolicy>,
}
#[derive(Debug, PartialEq)]
pub enum CreateMemberError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
ResourceLimitExceeded(String),
ResourceNotFound(String),
ResourceNotReady(String),
Throttling(String),
}
impl CreateMemberError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateMemberError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateMemberError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(CreateMemberError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateMemberError::InvalidRequest(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateMemberError::ResourceAlreadyExists(err.msg))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(CreateMemberError::ResourceLimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateMemberError::ResourceNotFound(err.msg))
}
"ResourceNotReadyException" => {
return RusotoError::Service(CreateMemberError::ResourceNotReady(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreateMemberError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateMemberError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateMemberError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateMemberError::InternalServiceError(ref cause) => write!(f, "{}", cause),
CreateMemberError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateMemberError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateMemberError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateMemberError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateMemberError::ResourceNotReady(ref cause) => write!(f, "{}", cause),
CreateMemberError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateMemberError {}
#[derive(Debug, PartialEq)]
pub enum CreateNetworkError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
ResourceLimitExceeded(String),
Throttling(String),
}
impl CreateNetworkError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateNetworkError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateNetworkError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(CreateNetworkError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateNetworkError::InvalidRequest(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateNetworkError::ResourceAlreadyExists(err.msg))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(CreateNetworkError::ResourceLimitExceeded(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreateNetworkError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateNetworkError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateNetworkError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateNetworkError::InternalServiceError(ref cause) => write!(f, "{}", cause),
CreateNetworkError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateNetworkError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateNetworkError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateNetworkError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateNetworkError {}
#[derive(Debug, PartialEq)]
pub enum CreateNodeError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
ResourceLimitExceeded(String),
ResourceNotFound(String),
ResourceNotReady(String),
Throttling(String),
}
impl CreateNodeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateNodeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateNodeError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(CreateNodeError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateNodeError::InvalidRequest(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateNodeError::ResourceAlreadyExists(err.msg))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(CreateNodeError::ResourceLimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateNodeError::ResourceNotFound(err.msg))
}
"ResourceNotReadyException" => {
return RusotoError::Service(CreateNodeError::ResourceNotReady(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreateNodeError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateNodeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateNodeError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateNodeError::InternalServiceError(ref cause) => write!(f, "{}", cause),
CreateNodeError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateNodeError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateNodeError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateNodeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateNodeError::ResourceNotReady(ref cause) => write!(f, "{}", cause),
CreateNodeError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateNodeError {}
#[derive(Debug, PartialEq)]
pub enum CreateProposalError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceNotFound(String),
ResourceNotReady(String),
Throttling(String),
}
impl CreateProposalError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateProposalError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateProposalError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(CreateProposalError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateProposalError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateProposalError::ResourceNotFound(err.msg))
}
"ResourceNotReadyException" => {
return RusotoError::Service(CreateProposalError::ResourceNotReady(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreateProposalError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateProposalError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateProposalError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateProposalError::InternalServiceError(ref cause) => write!(f, "{}", cause),
CreateProposalError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateProposalError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateProposalError::ResourceNotReady(ref cause) => write!(f, "{}", cause),
CreateProposalError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateProposalError {}
#[derive(Debug, PartialEq)]
pub enum DeleteMemberError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceNotFound(String),
ResourceNotReady(String),
Throttling(String),
}
impl DeleteMemberError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteMemberError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteMemberError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(DeleteMemberError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteMemberError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteMemberError::ResourceNotFound(err.msg))
}
"ResourceNotReadyException" => {
return RusotoError::Service(DeleteMemberError::ResourceNotReady(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteMemberError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteMemberError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteMemberError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteMemberError::InternalServiceError(ref cause) => write!(f, "{}", cause),
DeleteMemberError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteMemberError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteMemberError::ResourceNotReady(ref cause) => write!(f, "{}", cause),
DeleteMemberError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteMemberError {}
#[derive(Debug, PartialEq)]
pub enum DeleteNodeError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceNotFound(String),
ResourceNotReady(String),
Throttling(String),
}
impl DeleteNodeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteNodeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteNodeError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(DeleteNodeError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteNodeError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteNodeError::ResourceNotFound(err.msg))
}
"ResourceNotReadyException" => {
return RusotoError::Service(DeleteNodeError::ResourceNotReady(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteNodeError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteNodeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteNodeError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteNodeError::InternalServiceError(ref cause) => write!(f, "{}", cause),
DeleteNodeError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteNodeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteNodeError::ResourceNotReady(ref cause) => write!(f, "{}", cause),
DeleteNodeError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteNodeError {}
#[derive(Debug, PartialEq)]
pub enum GetMemberError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetMemberError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMemberError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetMemberError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(GetMemberError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetMemberError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetMemberError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(GetMemberError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetMemberError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMemberError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetMemberError::InternalServiceError(ref cause) => write!(f, "{}", cause),
GetMemberError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetMemberError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetMemberError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMemberError {}
#[derive(Debug, PartialEq)]
pub enum GetNetworkError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetNetworkError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetNetworkError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetNetworkError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(GetNetworkError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetNetworkError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetNetworkError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(GetNetworkError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetNetworkError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetNetworkError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetNetworkError::InternalServiceError(ref cause) => write!(f, "{}", cause),
GetNetworkError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetNetworkError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetNetworkError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetNetworkError {}
#[derive(Debug, PartialEq)]
pub enum GetNodeError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetNodeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetNodeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetNodeError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(GetNodeError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetNodeError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetNodeError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(GetNodeError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetNodeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetNodeError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetNodeError::InternalServiceError(ref cause) => write!(f, "{}", cause),
GetNodeError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetNodeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetNodeError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetNodeError {}
#[derive(Debug, PartialEq)]
pub enum GetProposalError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetProposalError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetProposalError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetProposalError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(GetProposalError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetProposalError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetProposalError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(GetProposalError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetProposalError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetProposalError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetProposalError::InternalServiceError(ref cause) => write!(f, "{}", cause),
GetProposalError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetProposalError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetProposalError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetProposalError {}
#[derive(Debug, PartialEq)]
pub enum ListInvitationsError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceLimitExceeded(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListInvitationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListInvitationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListInvitationsError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(ListInvitationsError::InternalServiceError(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListInvitationsError::InvalidRequest(err.msg))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(ListInvitationsError::ResourceLimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListInvitationsError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListInvitationsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListInvitationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListInvitationsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListInvitationsError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListInvitationsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListInvitationsError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
ListInvitationsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListInvitationsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListInvitationsError {}
#[derive(Debug, PartialEq)]
pub enum ListMembersError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
Throttling(String),
}
impl ListMembersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListMembersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListMembersError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(ListMembersError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListMembersError::InvalidRequest(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListMembersError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListMembersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListMembersError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListMembersError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListMembersError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListMembersError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListMembersError {}
#[derive(Debug, PartialEq)]
pub enum ListNetworksError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
Throttling(String),
}
impl ListNetworksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListNetworksError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListNetworksError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(ListNetworksError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListNetworksError::InvalidRequest(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListNetworksError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListNetworksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListNetworksError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListNetworksError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListNetworksError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListNetworksError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListNetworksError {}
#[derive(Debug, PartialEq)]
pub enum ListNodesError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
Throttling(String),
}
impl ListNodesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListNodesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListNodesError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(ListNodesError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListNodesError::InvalidRequest(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListNodesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListNodesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListNodesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListNodesError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListNodesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListNodesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListNodesError {}
#[derive(Debug, PartialEq)]
pub enum ListProposalVotesError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
Throttling(String),
}
impl ListProposalVotesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListProposalVotesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListProposalVotesError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(ListProposalVotesError::InternalServiceError(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListProposalVotesError::InvalidRequest(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListProposalVotesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListProposalVotesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListProposalVotesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListProposalVotesError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListProposalVotesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListProposalVotesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListProposalVotesError {}
#[derive(Debug, PartialEq)]
pub enum ListProposalsError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListProposalsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListProposalsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListProposalsError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(ListProposalsError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListProposalsError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListProposalsError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListProposalsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListProposalsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListProposalsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListProposalsError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListProposalsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListProposalsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListProposalsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListProposalsError {}
#[derive(Debug, PartialEq)]
pub enum RejectInvitationError {
AccessDenied(String),
IllegalAction(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl RejectInvitationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RejectInvitationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(RejectInvitationError::AccessDenied(err.msg))
}
"IllegalActionException" => {
return RusotoError::Service(RejectInvitationError::IllegalAction(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(RejectInvitationError::InternalServiceError(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(RejectInvitationError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(RejectInvitationError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(RejectInvitationError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RejectInvitationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RejectInvitationError::AccessDenied(ref cause) => write!(f, "{}", cause),
RejectInvitationError::IllegalAction(ref cause) => write!(f, "{}", cause),
RejectInvitationError::InternalServiceError(ref cause) => write!(f, "{}", cause),
RejectInvitationError::InvalidRequest(ref cause) => write!(f, "{}", cause),
RejectInvitationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
RejectInvitationError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RejectInvitationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateMemberError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateMemberError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateMemberError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateMemberError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(UpdateMemberError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateMemberError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateMemberError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateMemberError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateMemberError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateMemberError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateMemberError::InternalServiceError(ref cause) => write!(f, "{}", cause),
UpdateMemberError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateMemberError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateMemberError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateMemberError {}
#[derive(Debug, PartialEq)]
pub enum UpdateNodeError {
AccessDenied(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateNodeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateNodeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateNodeError::AccessDenied(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(UpdateNodeError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateNodeError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateNodeError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateNodeError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateNodeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateNodeError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateNodeError::InternalServiceError(ref cause) => write!(f, "{}", cause),
UpdateNodeError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateNodeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateNodeError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateNodeError {}
#[derive(Debug, PartialEq)]
pub enum VoteOnProposalError {
AccessDenied(String),
IllegalAction(String),
InternalServiceError(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl VoteOnProposalError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<VoteOnProposalError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(VoteOnProposalError::AccessDenied(err.msg))
}
"IllegalActionException" => {
return RusotoError::Service(VoteOnProposalError::IllegalAction(err.msg))
}
"InternalServiceErrorException" => {
return RusotoError::Service(VoteOnProposalError::InternalServiceError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(VoteOnProposalError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(VoteOnProposalError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(VoteOnProposalError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for VoteOnProposalError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
VoteOnProposalError::AccessDenied(ref cause) => write!(f, "{}", cause),
VoteOnProposalError::IllegalAction(ref cause) => write!(f, "{}", cause),
VoteOnProposalError::InternalServiceError(ref cause) => write!(f, "{}", cause),
VoteOnProposalError::InvalidRequest(ref cause) => write!(f, "{}", cause),
VoteOnProposalError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
VoteOnProposalError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for VoteOnProposalError {}
#[async_trait]
pub trait ManagedBlockchain {
async fn create_member(
&self,
input: CreateMemberInput,
) -> Result<CreateMemberOutput, RusotoError<CreateMemberError>>;
async fn create_network(
&self,
input: CreateNetworkInput,
) -> Result<CreateNetworkOutput, RusotoError<CreateNetworkError>>;
async fn create_node(
&self,
input: CreateNodeInput,
) -> Result<CreateNodeOutput, RusotoError<CreateNodeError>>;
async fn create_proposal(
&self,
input: CreateProposalInput,
) -> Result<CreateProposalOutput, RusotoError<CreateProposalError>>;
async fn delete_member(
&self,
input: DeleteMemberInput,
) -> Result<DeleteMemberOutput, RusotoError<DeleteMemberError>>;
async fn delete_node(
&self,
input: DeleteNodeInput,
) -> Result<DeleteNodeOutput, RusotoError<DeleteNodeError>>;
async fn get_member(
&self,
input: GetMemberInput,
) -> Result<GetMemberOutput, RusotoError<GetMemberError>>;
async fn get_network(
&self,
input: GetNetworkInput,
) -> Result<GetNetworkOutput, RusotoError<GetNetworkError>>;
async fn get_node(
&self,
input: GetNodeInput,
) -> Result<GetNodeOutput, RusotoError<GetNodeError>>;
async fn get_proposal(
&self,
input: GetProposalInput,
) -> Result<GetProposalOutput, RusotoError<GetProposalError>>;
async fn list_invitations(
&self,
input: ListInvitationsInput,
) -> Result<ListInvitationsOutput, RusotoError<ListInvitationsError>>;
async fn list_members(
&self,
input: ListMembersInput,
) -> Result<ListMembersOutput, RusotoError<ListMembersError>>;
async fn list_networks(
&self,
input: ListNetworksInput,
) -> Result<ListNetworksOutput, RusotoError<ListNetworksError>>;
async fn list_nodes(
&self,
input: ListNodesInput,
) -> Result<ListNodesOutput, RusotoError<ListNodesError>>;
async fn list_proposal_votes(
&self,
input: ListProposalVotesInput,
) -> Result<ListProposalVotesOutput, RusotoError<ListProposalVotesError>>;
async fn list_proposals(
&self,
input: ListProposalsInput,
) -> Result<ListProposalsOutput, RusotoError<ListProposalsError>>;
async fn reject_invitation(
&self,
input: RejectInvitationInput,
) -> Result<RejectInvitationOutput, RusotoError<RejectInvitationError>>;
async fn update_member(
&self,
input: UpdateMemberInput,
) -> Result<UpdateMemberOutput, RusotoError<UpdateMemberError>>;
async fn update_node(
&self,
input: UpdateNodeInput,
) -> Result<UpdateNodeOutput, RusotoError<UpdateNodeError>>;
async fn vote_on_proposal(
&self,
input: VoteOnProposalInput,
) -> Result<VoteOnProposalOutput, RusotoError<VoteOnProposalError>>;
}
#[derive(Clone)]
pub struct ManagedBlockchainClient {
client: Client,
region: region::Region,
}
impl ManagedBlockchainClient {
pub fn new(region: region::Region) -> ManagedBlockchainClient {
ManagedBlockchainClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ManagedBlockchainClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ManagedBlockchainClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ManagedBlockchainClient {
ManagedBlockchainClient { client, region }
}
}
#[async_trait]
impl ManagedBlockchain for ManagedBlockchainClient {
#[allow(unused_mut)]
async fn create_member(
&self,
input: CreateMemberInput,
) -> Result<CreateMemberOutput, RusotoError<CreateMemberError>> {
let request_uri = format!(
"/networks/{network_id}/members",
network_id = input.network_id
);
let mut request =
SignedRequest::new("POST", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateMemberOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateMemberError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_network(
&self,
input: CreateNetworkInput,
) -> Result<CreateNetworkOutput, RusotoError<CreateNetworkError>> {
let request_uri = "/networks";
let mut request =
SignedRequest::new("POST", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateNetworkOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateNetworkError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_node(
&self,
input: CreateNodeInput,
) -> Result<CreateNodeOutput, RusotoError<CreateNodeError>> {
let request_uri = format!(
"/networks/{network_id}/nodes",
network_id = input.network_id
);
let mut request =
SignedRequest::new("POST", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateNodeOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateNodeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_proposal(
&self,
input: CreateProposalInput,
) -> Result<CreateProposalOutput, RusotoError<CreateProposalError>> {
let request_uri = format!(
"/networks/{network_id}/proposals",
network_id = input.network_id
);
let mut request =
SignedRequest::new("POST", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateProposalOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateProposalError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_member(
&self,
input: DeleteMemberInput,
) -> Result<DeleteMemberOutput, RusotoError<DeleteMemberError>> {
let request_uri = format!(
"/networks/{network_id}/members/{member_id}",
member_id = input.member_id,
network_id = input.network_id
);
let mut request =
SignedRequest::new("DELETE", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteMemberOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteMemberError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_node(
&self,
input: DeleteNodeInput,
) -> Result<DeleteNodeOutput, RusotoError<DeleteNodeError>> {
let request_uri = format!(
"/networks/{network_id}/nodes/{node_id}",
network_id = input.network_id,
node_id = input.node_id
);
let mut request =
SignedRequest::new("DELETE", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.member_id {
params.put("memberId", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteNodeOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteNodeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_member(
&self,
input: GetMemberInput,
) -> Result<GetMemberOutput, RusotoError<GetMemberError>> {
let request_uri = format!(
"/networks/{network_id}/members/{member_id}",
member_id = input.member_id,
network_id = input.network_id
);
let mut request =
SignedRequest::new("GET", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<GetMemberOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetMemberError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_network(
&self,
input: GetNetworkInput,
) -> Result<GetNetworkOutput, RusotoError<GetNetworkError>> {
let request_uri = format!("/networks/{network_id}", network_id = input.network_id);
let mut request =
SignedRequest::new("GET", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetNetworkOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetNetworkError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_node(
&self,
input: GetNodeInput,
) -> Result<GetNodeOutput, RusotoError<GetNodeError>> {
let request_uri = format!(
"/networks/{network_id}/nodes/{node_id}",
network_id = input.network_id,
node_id = input.node_id
);
let mut request =
SignedRequest::new("GET", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.member_id {
params.put("memberId", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<GetNodeOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetNodeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_proposal(
&self,
input: GetProposalInput,
) -> Result<GetProposalOutput, RusotoError<GetProposalError>> {
let request_uri = format!(
"/networks/{network_id}/proposals/{proposal_id}",
network_id = input.network_id,
proposal_id = input.proposal_id
);
let mut request =
SignedRequest::new("GET", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetProposalOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetProposalError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_invitations(
&self,
input: ListInvitationsInput,
) -> Result<ListInvitationsOutput, RusotoError<ListInvitationsError>> {
let request_uri = "/invitations";
let mut request =
SignedRequest::new("GET", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListInvitationsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListInvitationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_members(
&self,
input: ListMembersInput,
) -> Result<ListMembersOutput, RusotoError<ListMembersError>> {
let request_uri = format!(
"/networks/{network_id}/members",
network_id = input.network_id
);
let mut request =
SignedRequest::new("GET", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.is_owned {
params.put("isOwned", x);
}
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.name {
params.put("name", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
if let Some(ref x) = input.status {
params.put("status", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListMembersOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListMembersError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_networks(
&self,
input: ListNetworksInput,
) -> Result<ListNetworksOutput, RusotoError<ListNetworksError>> {
let request_uri = "/networks";
let mut request =
SignedRequest::new("GET", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.framework {
params.put("framework", x);
}
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.name {
params.put("name", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
if let Some(ref x) = input.status {
params.put("status", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListNetworksOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListNetworksError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_nodes(
&self,
input: ListNodesInput,
) -> Result<ListNodesOutput, RusotoError<ListNodesError>> {
let request_uri = format!(
"/networks/{network_id}/nodes",
network_id = input.network_id
);
let mut request =
SignedRequest::new("GET", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.member_id {
params.put("memberId", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
if let Some(ref x) = input.status {
params.put("status", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<ListNodesOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListNodesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_proposal_votes(
&self,
input: ListProposalVotesInput,
) -> Result<ListProposalVotesOutput, RusotoError<ListProposalVotesError>> {
let request_uri = format!(
"/networks/{network_id}/proposals/{proposal_id}/votes",
network_id = input.network_id,
proposal_id = input.proposal_id
);
let mut request =
SignedRequest::new("GET", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListProposalVotesOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListProposalVotesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_proposals(
&self,
input: ListProposalsInput,
) -> Result<ListProposalsOutput, RusotoError<ListProposalsError>> {
let request_uri = format!(
"/networks/{network_id}/proposals",
network_id = input.network_id
);
let mut request =
SignedRequest::new("GET", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListProposalsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListProposalsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn reject_invitation(
&self,
input: RejectInvitationInput,
) -> Result<RejectInvitationOutput, RusotoError<RejectInvitationError>> {
let request_uri = format!(
"/invitations/{invitation_id}",
invitation_id = input.invitation_id
);
let mut request =
SignedRequest::new("DELETE", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RejectInvitationOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RejectInvitationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_member(
&self,
input: UpdateMemberInput,
) -> Result<UpdateMemberOutput, RusotoError<UpdateMemberError>> {
let request_uri = format!(
"/networks/{network_id}/members/{member_id}",
member_id = input.member_id,
network_id = input.network_id
);
let mut request =
SignedRequest::new("PATCH", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateMemberOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateMemberError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_node(
&self,
input: UpdateNodeInput,
) -> Result<UpdateNodeOutput, RusotoError<UpdateNodeError>> {
let request_uri = format!(
"/networks/{network_id}/nodes/{node_id}",
network_id = input.network_id,
node_id = input.node_id
);
let mut request =
SignedRequest::new("PATCH", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateNodeOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateNodeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn vote_on_proposal(
&self,
input: VoteOnProposalInput,
) -> Result<VoteOnProposalOutput, RusotoError<VoteOnProposalError>> {
let request_uri = format!(
"/networks/{network_id}/proposals/{proposal_id}/votes",
network_id = input.network_id,
proposal_id = input.proposal_id
);
let mut request =
SignedRequest::new("POST", "managedblockchain", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<VoteOnProposalOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(VoteOnProposalError::from_response(response))
}
}
}