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::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddTagsToResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagList")]
pub tag_list: Vec<Tag>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddTagsToResourceResponse {
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateHapgRequest {
#[serde(rename = "Label")]
pub label: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateHapgResponse {
#[serde(rename = "HapgArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hapg_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateHsmRequest {
#[serde(rename = "ClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "EniIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub eni_ip: Option<String>,
#[serde(rename = "ExternalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external_id: Option<String>,
#[serde(rename = "IamRoleArn")]
pub iam_role_arn: String,
#[serde(rename = "SshKey")]
pub ssh_key: String,
#[serde(rename = "SubnetId")]
pub subnet_id: String,
#[serde(rename = "SubscriptionType")]
pub subscription_type: String,
#[serde(rename = "SyslogIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub syslog_ip: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateHsmResponse {
#[serde(rename = "HsmArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hsm_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLunaClientRequest {
#[serde(rename = "Certificate")]
pub certificate: String,
#[serde(rename = "Label")]
#[serde(skip_serializing_if = "Option::is_none")]
pub label: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLunaClientResponse {
#[serde(rename = "ClientArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteHapgRequest {
#[serde(rename = "HapgArn")]
pub hapg_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteHapgResponse {
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteHsmRequest {
#[serde(rename = "HsmArn")]
pub hsm_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteHsmResponse {
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteLunaClientRequest {
#[serde(rename = "ClientArn")]
pub client_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteLunaClientResponse {
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeHapgRequest {
#[serde(rename = "HapgArn")]
pub hapg_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeHapgResponse {
#[serde(rename = "HapgArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hapg_arn: Option<String>,
#[serde(rename = "HapgSerial")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hapg_serial: Option<String>,
#[serde(rename = "HsmsLastActionFailed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hsms_last_action_failed: Option<Vec<String>>,
#[serde(rename = "HsmsPendingDeletion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hsms_pending_deletion: Option<Vec<String>>,
#[serde(rename = "HsmsPendingRegistration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hsms_pending_registration: Option<Vec<String>>,
#[serde(rename = "Label")]
#[serde(skip_serializing_if = "Option::is_none")]
pub label: Option<String>,
#[serde(rename = "LastModifiedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_timestamp: Option<String>,
#[serde(rename = "PartitionSerialList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub partition_serial_list: Option<Vec<String>>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeHsmRequest {
#[serde(rename = "HsmArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hsm_arn: Option<String>,
#[serde(rename = "HsmSerialNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hsm_serial_number: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeHsmResponse {
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "EniId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub eni_id: Option<String>,
#[serde(rename = "EniIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub eni_ip: Option<String>,
#[serde(rename = "HsmArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hsm_arn: Option<String>,
#[serde(rename = "HsmType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hsm_type: Option<String>,
#[serde(rename = "IamRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role_arn: Option<String>,
#[serde(rename = "Partitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub partitions: Option<Vec<String>>,
#[serde(rename = "SerialNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub serial_number: Option<String>,
#[serde(rename = "ServerCertLastUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_cert_last_updated: Option<String>,
#[serde(rename = "ServerCertUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_cert_uri: Option<String>,
#[serde(rename = "SoftwareVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub software_version: Option<String>,
#[serde(rename = "SshKeyLastUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_key_last_updated: Option<String>,
#[serde(rename = "SshPublicKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssh_public_key: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_details: Option<String>,
#[serde(rename = "SubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
#[serde(rename = "SubscriptionEndDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_end_date: Option<String>,
#[serde(rename = "SubscriptionStartDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_start_date: Option<String>,
#[serde(rename = "SubscriptionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_type: Option<String>,
#[serde(rename = "VendorName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vendor_name: Option<String>,
#[serde(rename = "VpcId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeLunaClientRequest {
#[serde(rename = "CertificateFingerprint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_fingerprint: Option<String>,
#[serde(rename = "ClientArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeLunaClientResponse {
#[serde(rename = "Certificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate: Option<String>,
#[serde(rename = "CertificateFingerprint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_fingerprint: Option<String>,
#[serde(rename = "ClientArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_arn: Option<String>,
#[serde(rename = "Label")]
#[serde(skip_serializing_if = "Option::is_none")]
pub label: Option<String>,
#[serde(rename = "LastModifiedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_timestamp: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetConfigRequest {
#[serde(rename = "ClientArn")]
pub client_arn: String,
#[serde(rename = "ClientVersion")]
pub client_version: String,
#[serde(rename = "HapgList")]
pub hapg_list: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetConfigResponse {
#[serde(rename = "ConfigCred")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_cred: Option<String>,
#[serde(rename = "ConfigFile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_file: Option<String>,
#[serde(rename = "ConfigType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAvailableZonesRequest {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAvailableZonesResponse {
#[serde(rename = "AZList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub az_list: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListHapgsRequest {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListHapgsResponse {
#[serde(rename = "HapgList")]
pub hapg_list: Vec<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListHsmsRequest {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListHsmsResponse {
#[serde(rename = "HsmList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hsm_list: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListLunaClientsRequest {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListLunaClientsResponse {
#[serde(rename = "ClientList")]
pub client_list: Vec<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "TagList")]
pub tag_list: Vec<Tag>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyHapgRequest {
#[serde(rename = "HapgArn")]
pub hapg_arn: String,
#[serde(rename = "Label")]
#[serde(skip_serializing_if = "Option::is_none")]
pub label: Option<String>,
#[serde(rename = "PartitionSerialList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub partition_serial_list: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModifyHapgResponse {
#[serde(rename = "HapgArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hapg_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyHsmRequest {
#[serde(rename = "EniIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub eni_ip: Option<String>,
#[serde(rename = "ExternalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external_id: Option<String>,
#[serde(rename = "HsmArn")]
pub hsm_arn: String,
#[serde(rename = "IamRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role_arn: Option<String>,
#[serde(rename = "SubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
#[serde(rename = "SyslogIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub syslog_ip: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModifyHsmResponse {
#[serde(rename = "HsmArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hsm_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyLunaClientRequest {
#[serde(rename = "Certificate")]
pub certificate: String,
#[serde(rename = "ClientArn")]
pub client_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModifyLunaClientResponse {
#[serde(rename = "ClientArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemoveTagsFromResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeyList")]
pub tag_key_list: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RemoveTagsFromResourceResponse {
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Tag {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Debug, PartialEq)]
pub enum AddTagsToResourceError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl AddTagsToResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddTagsToResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(AddTagsToResourceError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(AddTagsToResourceError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(AddTagsToResourceError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddTagsToResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddTagsToResourceError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
AddTagsToResourceError::CloudHsmService(ref cause) => write!(f, "{}", cause),
AddTagsToResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddTagsToResourceError {}
#[derive(Debug, PartialEq)]
pub enum CreateHapgError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl CreateHapgError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateHapgError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(CreateHapgError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(CreateHapgError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateHapgError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateHapgError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateHapgError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
CreateHapgError::CloudHsmService(ref cause) => write!(f, "{}", cause),
CreateHapgError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateHapgError {}
#[derive(Debug, PartialEq)]
pub enum CreateHsmError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl CreateHsmError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateHsmError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(CreateHsmError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(CreateHsmError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateHsmError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateHsmError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateHsmError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
CreateHsmError::CloudHsmService(ref cause) => write!(f, "{}", cause),
CreateHsmError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateHsmError {}
#[derive(Debug, PartialEq)]
pub enum CreateLunaClientError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl CreateLunaClientError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLunaClientError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(CreateLunaClientError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(CreateLunaClientError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateLunaClientError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLunaClientError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLunaClientError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
CreateLunaClientError::CloudHsmService(ref cause) => write!(f, "{}", cause),
CreateLunaClientError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLunaClientError {}
#[derive(Debug, PartialEq)]
pub enum DeleteHapgError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl DeleteHapgError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteHapgError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(DeleteHapgError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(DeleteHapgError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteHapgError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteHapgError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteHapgError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
DeleteHapgError::CloudHsmService(ref cause) => write!(f, "{}", cause),
DeleteHapgError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteHapgError {}
#[derive(Debug, PartialEq)]
pub enum DeleteHsmError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl DeleteHsmError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteHsmError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(DeleteHsmError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(DeleteHsmError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteHsmError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteHsmError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteHsmError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
DeleteHsmError::CloudHsmService(ref cause) => write!(f, "{}", cause),
DeleteHsmError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteHsmError {}
#[derive(Debug, PartialEq)]
pub enum DeleteLunaClientError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl DeleteLunaClientError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteLunaClientError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(DeleteLunaClientError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(DeleteLunaClientError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteLunaClientError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLunaClientError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLunaClientError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
DeleteLunaClientError::CloudHsmService(ref cause) => write!(f, "{}", cause),
DeleteLunaClientError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteLunaClientError {}
#[derive(Debug, PartialEq)]
pub enum DescribeHapgError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl DescribeHapgError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeHapgError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(DescribeHapgError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(DescribeHapgError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeHapgError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeHapgError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeHapgError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
DescribeHapgError::CloudHsmService(ref cause) => write!(f, "{}", cause),
DescribeHapgError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeHapgError {}
#[derive(Debug, PartialEq)]
pub enum DescribeHsmError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl DescribeHsmError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeHsmError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(DescribeHsmError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(DescribeHsmError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeHsmError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeHsmError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeHsmError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
DescribeHsmError::CloudHsmService(ref cause) => write!(f, "{}", cause),
DescribeHsmError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeHsmError {}
#[derive(Debug, PartialEq)]
pub enum DescribeLunaClientError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl DescribeLunaClientError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLunaClientError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(DescribeLunaClientError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(DescribeLunaClientError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeLunaClientError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeLunaClientError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLunaClientError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
DescribeLunaClientError::CloudHsmService(ref cause) => write!(f, "{}", cause),
DescribeLunaClientError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLunaClientError {}
#[derive(Debug, PartialEq)]
pub enum GetConfigError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl GetConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetConfigError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(GetConfigError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(GetConfigError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetConfigError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetConfigError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
GetConfigError::CloudHsmService(ref cause) => write!(f, "{}", cause),
GetConfigError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetConfigError {}
#[derive(Debug, PartialEq)]
pub enum ListAvailableZonesError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl ListAvailableZonesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAvailableZonesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(ListAvailableZonesError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(ListAvailableZonesError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListAvailableZonesError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAvailableZonesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAvailableZonesError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
ListAvailableZonesError::CloudHsmService(ref cause) => write!(f, "{}", cause),
ListAvailableZonesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListAvailableZonesError {}
#[derive(Debug, PartialEq)]
pub enum ListHapgsError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl ListHapgsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListHapgsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(ListHapgsError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(ListHapgsError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListHapgsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListHapgsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListHapgsError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
ListHapgsError::CloudHsmService(ref cause) => write!(f, "{}", cause),
ListHapgsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListHapgsError {}
#[derive(Debug, PartialEq)]
pub enum ListHsmsError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl ListHsmsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListHsmsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(ListHsmsError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(ListHsmsError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListHsmsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListHsmsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListHsmsError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
ListHsmsError::CloudHsmService(ref cause) => write!(f, "{}", cause),
ListHsmsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListHsmsError {}
#[derive(Debug, PartialEq)]
pub enum ListLunaClientsError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl ListLunaClientsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLunaClientsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(ListLunaClientsError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(ListLunaClientsError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListLunaClientsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLunaClientsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLunaClientsError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
ListLunaClientsError::CloudHsmService(ref cause) => write!(f, "{}", cause),
ListLunaClientsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLunaClientsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(ListTagsForResourceError::CloudHsmInternal(
err.msg,
))
}
"CloudHsmServiceException" => {
return RusotoError::Service(ListTagsForResourceError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::CloudHsmService(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ModifyHapgError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl ModifyHapgError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyHapgError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(ModifyHapgError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(ModifyHapgError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ModifyHapgError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ModifyHapgError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyHapgError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
ModifyHapgError::CloudHsmService(ref cause) => write!(f, "{}", cause),
ModifyHapgError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ModifyHapgError {}
#[derive(Debug, PartialEq)]
pub enum ModifyHsmError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl ModifyHsmError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyHsmError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(ModifyHsmError::CloudHsmInternal(err.msg))
}
"CloudHsmServiceException" => {
return RusotoError::Service(ModifyHsmError::CloudHsmService(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ModifyHsmError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ModifyHsmError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyHsmError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
ModifyHsmError::CloudHsmService(ref cause) => write!(f, "{}", cause),
ModifyHsmError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ModifyHsmError {}
#[derive(Debug, PartialEq)]
pub enum ModifyLunaClientError {
CloudHsmService(String),
}
impl ModifyLunaClientError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyLunaClientError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmServiceException" => {
return RusotoError::Service(ModifyLunaClientError::CloudHsmService(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ModifyLunaClientError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyLunaClientError::CloudHsmService(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ModifyLunaClientError {}
#[derive(Debug, PartialEq)]
pub enum RemoveTagsFromResourceError {
CloudHsmInternal(String),
CloudHsmService(String),
InvalidRequest(String),
}
impl RemoveTagsFromResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RemoveTagsFromResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CloudHsmInternalException" => {
return RusotoError::Service(RemoveTagsFromResourceError::CloudHsmInternal(
err.msg,
))
}
"CloudHsmServiceException" => {
return RusotoError::Service(RemoveTagsFromResourceError::CloudHsmService(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(RemoveTagsFromResourceError::InvalidRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RemoveTagsFromResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemoveTagsFromResourceError::CloudHsmInternal(ref cause) => write!(f, "{}", cause),
RemoveTagsFromResourceError::CloudHsmService(ref cause) => write!(f, "{}", cause),
RemoveTagsFromResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemoveTagsFromResourceError {}
#[async_trait]
pub trait CloudHsm {
async fn add_tags_to_resource(
&self,
input: AddTagsToResourceRequest,
) -> Result<AddTagsToResourceResponse, RusotoError<AddTagsToResourceError>>;
async fn create_hapg(
&self,
input: CreateHapgRequest,
) -> Result<CreateHapgResponse, RusotoError<CreateHapgError>>;
async fn create_hsm(
&self,
input: CreateHsmRequest,
) -> Result<CreateHsmResponse, RusotoError<CreateHsmError>>;
async fn create_luna_client(
&self,
input: CreateLunaClientRequest,
) -> Result<CreateLunaClientResponse, RusotoError<CreateLunaClientError>>;
async fn delete_hapg(
&self,
input: DeleteHapgRequest,
) -> Result<DeleteHapgResponse, RusotoError<DeleteHapgError>>;
async fn delete_hsm(
&self,
input: DeleteHsmRequest,
) -> Result<DeleteHsmResponse, RusotoError<DeleteHsmError>>;
async fn delete_luna_client(
&self,
input: DeleteLunaClientRequest,
) -> Result<DeleteLunaClientResponse, RusotoError<DeleteLunaClientError>>;
async fn describe_hapg(
&self,
input: DescribeHapgRequest,
) -> Result<DescribeHapgResponse, RusotoError<DescribeHapgError>>;
async fn describe_hsm(
&self,
input: DescribeHsmRequest,
) -> Result<DescribeHsmResponse, RusotoError<DescribeHsmError>>;
async fn describe_luna_client(
&self,
input: DescribeLunaClientRequest,
) -> Result<DescribeLunaClientResponse, RusotoError<DescribeLunaClientError>>;
async fn get_config(
&self,
input: GetConfigRequest,
) -> Result<GetConfigResponse, RusotoError<GetConfigError>>;
async fn list_available_zones(
&self,
) -> Result<ListAvailableZonesResponse, RusotoError<ListAvailableZonesError>>;
async fn list_hapgs(
&self,
input: ListHapgsRequest,
) -> Result<ListHapgsResponse, RusotoError<ListHapgsError>>;
async fn list_hsms(
&self,
input: ListHsmsRequest,
) -> Result<ListHsmsResponse, RusotoError<ListHsmsError>>;
async fn list_luna_clients(
&self,
input: ListLunaClientsRequest,
) -> Result<ListLunaClientsResponse, RusotoError<ListLunaClientsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn modify_hapg(
&self,
input: ModifyHapgRequest,
) -> Result<ModifyHapgResponse, RusotoError<ModifyHapgError>>;
async fn modify_hsm(
&self,
input: ModifyHsmRequest,
) -> Result<ModifyHsmResponse, RusotoError<ModifyHsmError>>;
async fn modify_luna_client(
&self,
input: ModifyLunaClientRequest,
) -> Result<ModifyLunaClientResponse, RusotoError<ModifyLunaClientError>>;
async fn remove_tags_from_resource(
&self,
input: RemoveTagsFromResourceRequest,
) -> Result<RemoveTagsFromResourceResponse, RusotoError<RemoveTagsFromResourceError>>;
}
#[derive(Clone)]
pub struct CloudHsmClient {
client: Client,
region: region::Region,
}
impl CloudHsmClient {
pub fn new(region: region::Region) -> CloudHsmClient {
CloudHsmClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CloudHsmClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
CloudHsmClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> CloudHsmClient {
CloudHsmClient { client, region }
}
}
#[async_trait]
impl CloudHsm for CloudHsmClient {
async fn add_tags_to_resource(
&self,
input: AddTagsToResourceRequest,
) -> Result<AddTagsToResourceResponse, RusotoError<AddTagsToResourceError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.AddTagsToResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AddTagsToResourceResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AddTagsToResourceError::from_response(response))
}
}
async fn create_hapg(
&self,
input: CreateHapgRequest,
) -> Result<CreateHapgResponse, RusotoError<CreateHapgError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.CreateHapg");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateHapgResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateHapgError::from_response(response))
}
}
async fn create_hsm(
&self,
input: CreateHsmRequest,
) -> Result<CreateHsmResponse, RusotoError<CreateHsmError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.CreateHsm");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateHsmResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateHsmError::from_response(response))
}
}
async fn create_luna_client(
&self,
input: CreateLunaClientRequest,
) -> Result<CreateLunaClientResponse, RusotoError<CreateLunaClientError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.CreateLunaClient");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateLunaClientResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateLunaClientError::from_response(response))
}
}
async fn delete_hapg(
&self,
input: DeleteHapgRequest,
) -> Result<DeleteHapgResponse, RusotoError<DeleteHapgError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.DeleteHapg");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteHapgResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteHapgError::from_response(response))
}
}
async fn delete_hsm(
&self,
input: DeleteHsmRequest,
) -> Result<DeleteHsmResponse, RusotoError<DeleteHsmError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.DeleteHsm");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteHsmResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteHsmError::from_response(response))
}
}
async fn delete_luna_client(
&self,
input: DeleteLunaClientRequest,
) -> Result<DeleteLunaClientResponse, RusotoError<DeleteLunaClientError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.DeleteLunaClient");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteLunaClientResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteLunaClientError::from_response(response))
}
}
async fn describe_hapg(
&self,
input: DescribeHapgRequest,
) -> Result<DescribeHapgResponse, RusotoError<DescribeHapgError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.DescribeHapg");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeHapgResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeHapgError::from_response(response))
}
}
async fn describe_hsm(
&self,
input: DescribeHsmRequest,
) -> Result<DescribeHsmResponse, RusotoError<DescribeHsmError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.DescribeHsm");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeHsmResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeHsmError::from_response(response))
}
}
async fn describe_luna_client(
&self,
input: DescribeLunaClientRequest,
) -> Result<DescribeLunaClientResponse, RusotoError<DescribeLunaClientError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.DescribeLunaClient");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeLunaClientResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeLunaClientError::from_response(response))
}
}
async fn get_config(
&self,
input: GetConfigRequest,
) -> Result<GetConfigResponse, RusotoError<GetConfigError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.GetConfig");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetConfigResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetConfigError::from_response(response))
}
}
async fn list_available_zones(
&self,
) -> Result<ListAvailableZonesResponse, RusotoError<ListAvailableZonesError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.ListAvailableZones");
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListAvailableZonesResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListAvailableZonesError::from_response(response))
}
}
async fn list_hapgs(
&self,
input: ListHapgsRequest,
) -> Result<ListHapgsResponse, RusotoError<ListHapgsError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.ListHapgs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListHapgsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListHapgsError::from_response(response))
}
}
async fn list_hsms(
&self,
input: ListHsmsRequest,
) -> Result<ListHsmsResponse, RusotoError<ListHsmsError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.ListHsms");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListHsmsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListHsmsError::from_response(response))
}
}
async fn list_luna_clients(
&self,
input: ListLunaClientsRequest,
) -> Result<ListLunaClientsResponse, RusotoError<ListLunaClientsError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.ListLunaClients");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListLunaClientsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListLunaClientsError::from_response(response))
}
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"CloudHsmFrontendService.ListTagsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
async fn modify_hapg(
&self,
input: ModifyHapgRequest,
) -> Result<ModifyHapgResponse, RusotoError<ModifyHapgError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.ModifyHapg");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ModifyHapgResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ModifyHapgError::from_response(response))
}
}
async fn modify_hsm(
&self,
input: ModifyHsmRequest,
) -> Result<ModifyHsmResponse, RusotoError<ModifyHsmError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.ModifyHsm");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ModifyHsmResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ModifyHsmError::from_response(response))
}
}
async fn modify_luna_client(
&self,
input: ModifyLunaClientRequest,
) -> Result<ModifyLunaClientResponse, RusotoError<ModifyLunaClientError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "CloudHsmFrontendService.ModifyLunaClient");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ModifyLunaClientResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ModifyLunaClientError::from_response(response))
}
}
async fn remove_tags_from_resource(
&self,
input: RemoveTagsFromResourceRequest,
) -> Result<RemoveTagsFromResourceResponse, RusotoError<RemoveTagsFromResourceError>> {
let mut request = SignedRequest::new("POST", "cloudhsm", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"CloudHsmFrontendService.RemoveTagsFromResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<RemoveTagsFromResourceResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(RemoveTagsFromResourceError::from_response(response))
}
}
}