use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl LakeFormationClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request =
SignedRequest::new(http_method, "lakeformation", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGrantPermissionsRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "Entries")]
pub entries: Vec<BatchPermissionsRequestEntry>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGrantPermissionsResponse {
#[serde(rename = "Failures")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failures: Option<Vec<BatchPermissionsFailureEntry>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchPermissionsFailureEntry {
#[serde(rename = "Error")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error: Option<ErrorDetail>,
#[serde(rename = "RequestEntry")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_entry: Option<BatchPermissionsRequestEntry>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct BatchPermissionsRequestEntry {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Permissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions: Option<Vec<String>>,
#[serde(rename = "PermissionsWithGrantOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions_with_grant_option: Option<Vec<String>>,
#[serde(rename = "Principal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principal: Option<DataLakePrincipal>,
#[serde(rename = "Resource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource: Option<Resource>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchRevokePermissionsRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "Entries")]
pub entries: Vec<BatchPermissionsRequestEntry>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchRevokePermissionsResponse {
#[serde(rename = "Failures")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failures: Option<Vec<BatchPermissionsFailureEntry>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CatalogResource {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ColumnWildcard {
#[serde(rename = "ExcludedColumnNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub excluded_column_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataLakePrincipal {
#[serde(rename = "DataLakePrincipalIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_lake_principal_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataLakeSettings {
#[serde(rename = "CreateDatabaseDefaultPermissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_database_default_permissions: Option<Vec<PrincipalPermissions>>,
#[serde(rename = "CreateTableDefaultPermissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_table_default_permissions: Option<Vec<PrincipalPermissions>>,
#[serde(rename = "DataLakeAdmins")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_lake_admins: Option<Vec<DataLakePrincipal>>,
#[serde(rename = "TrustedResourceOwners")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trusted_resource_owners: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataLocationResource {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DatabaseResource {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeregisterResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeregisterResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeResourceResponse {
#[serde(rename = "ResourceInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_info: Option<ResourceInfo>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DetailsMap {
#[serde(rename = "ResourceShare")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ErrorDetail {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct FilterCondition {
#[serde(rename = "ComparisonOperator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comparison_operator: Option<String>,
#[serde(rename = "Field")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field: Option<String>,
#[serde(rename = "StringValueList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub string_value_list: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDataLakeSettingsRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDataLakeSettingsResponse {
#[serde(rename = "DataLakeSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_lake_settings: Option<DataLakeSettings>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetEffectivePermissionsForPathRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetEffectivePermissionsForPathResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Permissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions: Option<Vec<PrincipalResourcePermissions>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GrantPermissionsRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "Permissions")]
pub permissions: Vec<String>,
#[serde(rename = "PermissionsWithGrantOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions_with_grant_option: Option<Vec<String>>,
#[serde(rename = "Principal")]
pub principal: DataLakePrincipal,
#[serde(rename = "Resource")]
pub resource: Resource,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GrantPermissionsResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPermissionsRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Principal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principal: Option<DataLakePrincipal>,
#[serde(rename = "Resource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource: Option<Resource>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPermissionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PrincipalResourcePermissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principal_resource_permissions: Option<Vec<PrincipalResourcePermissions>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListResourcesRequest {
#[serde(rename = "FilterConditionList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_condition_list: Option<Vec<FilterCondition>>,
#[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 ListResourcesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceInfoList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_info_list: Option<Vec<ResourceInfo>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct PrincipalPermissions {
#[serde(rename = "Permissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions: Option<Vec<String>>,
#[serde(rename = "Principal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principal: Option<DataLakePrincipal>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PrincipalResourcePermissions {
#[serde(rename = "AdditionalDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_details: Option<DetailsMap>,
#[serde(rename = "Permissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions: Option<Vec<String>>,
#[serde(rename = "PermissionsWithGrantOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions_with_grant_option: Option<Vec<String>>,
#[serde(rename = "Principal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principal: Option<DataLakePrincipal>,
#[serde(rename = "Resource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource: Option<Resource>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutDataLakeSettingsRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DataLakeSettings")]
pub data_lake_settings: DataLakeSettings,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutDataLakeSettingsResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RegisterResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "UseServiceLinkedRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_service_linked_role: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RegisterResourceResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Resource {
#[serde(rename = "Catalog")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog: Option<CatalogResource>,
#[serde(rename = "DataLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_location: Option<DataLocationResource>,
#[serde(rename = "Database")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database: Option<DatabaseResource>,
#[serde(rename = "Table")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table: Option<TableResource>,
#[serde(rename = "TableWithColumns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_with_columns: Option<TableWithColumnsResource>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceInfo {
#[serde(rename = "LastModified")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified: Option<f64>,
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RevokePermissionsRequest {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "Permissions")]
pub permissions: Vec<String>,
#[serde(rename = "PermissionsWithGrantOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions_with_grant_option: Option<Vec<String>>,
#[serde(rename = "Principal")]
pub principal: DataLakePrincipal,
#[serde(rename = "Resource")]
pub resource: Resource,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RevokePermissionsResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TableResource {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "TableWildcard")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_wildcard: Option<TableWildcard>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TableWildcard {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TableWithColumnsResource {
#[serde(rename = "CatalogId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub catalog_id: Option<String>,
#[serde(rename = "ColumnNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub column_names: Option<Vec<String>>,
#[serde(rename = "ColumnWildcard")]
#[serde(skip_serializing_if = "Option::is_none")]
pub column_wildcard: Option<ColumnWildcard>,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "RoleArn")]
pub role_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateResourceResponse {}
#[derive(Debug, PartialEq)]
pub enum BatchGrantPermissionsError {
InvalidInput(String),
OperationTimeout(String),
}
impl BatchGrantPermissionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchGrantPermissionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(BatchGrantPermissionsError::InvalidInput(err.msg))
}
"OperationTimeoutException" => {
return RusotoError::Service(BatchGrantPermissionsError::OperationTimeout(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGrantPermissionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGrantPermissionsError::InvalidInput(ref cause) => write!(f, "{}", cause),
BatchGrantPermissionsError::OperationTimeout(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchGrantPermissionsError {}
#[derive(Debug, PartialEq)]
pub enum BatchRevokePermissionsError {
InvalidInput(String),
OperationTimeout(String),
}
impl BatchRevokePermissionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchRevokePermissionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidInputException" => {
return RusotoError::Service(BatchRevokePermissionsError::InvalidInput(err.msg))
}
"OperationTimeoutException" => {
return RusotoError::Service(BatchRevokePermissionsError::OperationTimeout(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchRevokePermissionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchRevokePermissionsError::InvalidInput(ref cause) => write!(f, "{}", cause),
BatchRevokePermissionsError::OperationTimeout(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchRevokePermissionsError {}
#[derive(Debug, PartialEq)]
pub enum DeregisterResourceError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
}
impl DeregisterResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeregisterResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EntityNotFoundException" => {
return RusotoError::Service(DeregisterResourceError::EntityNotFound(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(DeregisterResourceError::InternalService(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(DeregisterResourceError::InvalidInput(err.msg))
}
"OperationTimeoutException" => {
return RusotoError::Service(DeregisterResourceError::OperationTimeout(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeregisterResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeregisterResourceError::EntityNotFound(ref cause) => write!(f, "{}", cause),
DeregisterResourceError::InternalService(ref cause) => write!(f, "{}", cause),
DeregisterResourceError::InvalidInput(ref cause) => write!(f, "{}", cause),
DeregisterResourceError::OperationTimeout(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeregisterResourceError {}
#[derive(Debug, PartialEq)]
pub enum DescribeResourceError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
}
impl DescribeResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EntityNotFoundException" => {
return RusotoError::Service(DescribeResourceError::EntityNotFound(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(DescribeResourceError::InternalService(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(DescribeResourceError::InvalidInput(err.msg))
}
"OperationTimeoutException" => {
return RusotoError::Service(DescribeResourceError::OperationTimeout(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeResourceError::EntityNotFound(ref cause) => write!(f, "{}", cause),
DescribeResourceError::InternalService(ref cause) => write!(f, "{}", cause),
DescribeResourceError::InvalidInput(ref cause) => write!(f, "{}", cause),
DescribeResourceError::OperationTimeout(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeResourceError {}
#[derive(Debug, PartialEq)]
pub enum GetDataLakeSettingsError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
}
impl GetDataLakeSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDataLakeSettingsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EntityNotFoundException" => {
return RusotoError::Service(GetDataLakeSettingsError::EntityNotFound(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(GetDataLakeSettingsError::InternalService(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GetDataLakeSettingsError::InvalidInput(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDataLakeSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDataLakeSettingsError::EntityNotFound(ref cause) => write!(f, "{}", cause),
GetDataLakeSettingsError::InternalService(ref cause) => write!(f, "{}", cause),
GetDataLakeSettingsError::InvalidInput(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDataLakeSettingsError {}
#[derive(Debug, PartialEq)]
pub enum GetEffectivePermissionsForPathError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
}
impl GetEffectivePermissionsForPathError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetEffectivePermissionsForPathError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EntityNotFoundException" => {
return RusotoError::Service(
GetEffectivePermissionsForPathError::EntityNotFound(err.msg),
)
}
"InternalServiceException" => {
return RusotoError::Service(
GetEffectivePermissionsForPathError::InternalService(err.msg),
)
}
"InvalidInputException" => {
return RusotoError::Service(GetEffectivePermissionsForPathError::InvalidInput(
err.msg,
))
}
"OperationTimeoutException" => {
return RusotoError::Service(
GetEffectivePermissionsForPathError::OperationTimeout(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetEffectivePermissionsForPathError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetEffectivePermissionsForPathError::EntityNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetEffectivePermissionsForPathError::InternalService(ref cause) => {
write!(f, "{}", cause)
}
GetEffectivePermissionsForPathError::InvalidInput(ref cause) => write!(f, "{}", cause),
GetEffectivePermissionsForPathError::OperationTimeout(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetEffectivePermissionsForPathError {}
#[derive(Debug, PartialEq)]
pub enum GrantPermissionsError {
ConcurrentModification(String),
EntityNotFound(String),
InvalidInput(String),
}
impl GrantPermissionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GrantPermissionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(GrantPermissionsError::ConcurrentModification(
err.msg,
))
}
"EntityNotFoundException" => {
return RusotoError::Service(GrantPermissionsError::EntityNotFound(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(GrantPermissionsError::InvalidInput(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GrantPermissionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GrantPermissionsError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
GrantPermissionsError::EntityNotFound(ref cause) => write!(f, "{}", cause),
GrantPermissionsError::InvalidInput(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GrantPermissionsError {}
#[derive(Debug, PartialEq)]
pub enum ListPermissionsError {
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
}
impl ListPermissionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPermissionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(ListPermissionsError::InternalService(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(ListPermissionsError::InvalidInput(err.msg))
}
"OperationTimeoutException" => {
return RusotoError::Service(ListPermissionsError::OperationTimeout(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPermissionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPermissionsError::InternalService(ref cause) => write!(f, "{}", cause),
ListPermissionsError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListPermissionsError::OperationTimeout(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPermissionsError {}
#[derive(Debug, PartialEq)]
pub enum ListResourcesError {
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
}
impl ListResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListResourcesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(ListResourcesError::InternalService(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(ListResourcesError::InvalidInput(err.msg))
}
"OperationTimeoutException" => {
return RusotoError::Service(ListResourcesError::OperationTimeout(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResourcesError::InternalService(ref cause) => write!(f, "{}", cause),
ListResourcesError::InvalidInput(ref cause) => write!(f, "{}", cause),
ListResourcesError::OperationTimeout(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListResourcesError {}
#[derive(Debug, PartialEq)]
pub enum PutDataLakeSettingsError {
InternalService(String),
InvalidInput(String),
}
impl PutDataLakeSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutDataLakeSettingsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(PutDataLakeSettingsError::InternalService(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(PutDataLakeSettingsError::InvalidInput(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutDataLakeSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutDataLakeSettingsError::InternalService(ref cause) => write!(f, "{}", cause),
PutDataLakeSettingsError::InvalidInput(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutDataLakeSettingsError {}
#[derive(Debug, PartialEq)]
pub enum RegisterResourceError {
AlreadyExists(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
}
impl RegisterResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RegisterResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AlreadyExistsException" => {
return RusotoError::Service(RegisterResourceError::AlreadyExists(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(RegisterResourceError::InternalService(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(RegisterResourceError::InvalidInput(err.msg))
}
"OperationTimeoutException" => {
return RusotoError::Service(RegisterResourceError::OperationTimeout(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RegisterResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RegisterResourceError::AlreadyExists(ref cause) => write!(f, "{}", cause),
RegisterResourceError::InternalService(ref cause) => write!(f, "{}", cause),
RegisterResourceError::InvalidInput(ref cause) => write!(f, "{}", cause),
RegisterResourceError::OperationTimeout(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RegisterResourceError {}
#[derive(Debug, PartialEq)]
pub enum RevokePermissionsError {
ConcurrentModification(String),
EntityNotFound(String),
InvalidInput(String),
}
impl RevokePermissionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RevokePermissionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(RevokePermissionsError::ConcurrentModification(
err.msg,
))
}
"EntityNotFoundException" => {
return RusotoError::Service(RevokePermissionsError::EntityNotFound(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(RevokePermissionsError::InvalidInput(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RevokePermissionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RevokePermissionsError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
RevokePermissionsError::EntityNotFound(ref cause) => write!(f, "{}", cause),
RevokePermissionsError::InvalidInput(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RevokePermissionsError {}
#[derive(Debug, PartialEq)]
pub enum UpdateResourceError {
EntityNotFound(String),
InternalService(String),
InvalidInput(String),
OperationTimeout(String),
}
impl UpdateResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EntityNotFoundException" => {
return RusotoError::Service(UpdateResourceError::EntityNotFound(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(UpdateResourceError::InternalService(err.msg))
}
"InvalidInputException" => {
return RusotoError::Service(UpdateResourceError::InvalidInput(err.msg))
}
"OperationTimeoutException" => {
return RusotoError::Service(UpdateResourceError::OperationTimeout(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateResourceError::EntityNotFound(ref cause) => write!(f, "{}", cause),
UpdateResourceError::InternalService(ref cause) => write!(f, "{}", cause),
UpdateResourceError::InvalidInput(ref cause) => write!(f, "{}", cause),
UpdateResourceError::OperationTimeout(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateResourceError {}
#[async_trait]
pub trait LakeFormation {
async fn batch_grant_permissions(
&self,
input: BatchGrantPermissionsRequest,
) -> Result<BatchGrantPermissionsResponse, RusotoError<BatchGrantPermissionsError>>;
async fn batch_revoke_permissions(
&self,
input: BatchRevokePermissionsRequest,
) -> Result<BatchRevokePermissionsResponse, RusotoError<BatchRevokePermissionsError>>;
async fn deregister_resource(
&self,
input: DeregisterResourceRequest,
) -> Result<DeregisterResourceResponse, RusotoError<DeregisterResourceError>>;
async fn describe_resource(
&self,
input: DescribeResourceRequest,
) -> Result<DescribeResourceResponse, RusotoError<DescribeResourceError>>;
async fn get_data_lake_settings(
&self,
input: GetDataLakeSettingsRequest,
) -> Result<GetDataLakeSettingsResponse, RusotoError<GetDataLakeSettingsError>>;
async fn get_effective_permissions_for_path(
&self,
input: GetEffectivePermissionsForPathRequest,
) -> Result<
GetEffectivePermissionsForPathResponse,
RusotoError<GetEffectivePermissionsForPathError>,
>;
async fn grant_permissions(
&self,
input: GrantPermissionsRequest,
) -> Result<GrantPermissionsResponse, RusotoError<GrantPermissionsError>>;
async fn list_permissions(
&self,
input: ListPermissionsRequest,
) -> Result<ListPermissionsResponse, RusotoError<ListPermissionsError>>;
async fn list_resources(
&self,
input: ListResourcesRequest,
) -> Result<ListResourcesResponse, RusotoError<ListResourcesError>>;
async fn put_data_lake_settings(
&self,
input: PutDataLakeSettingsRequest,
) -> Result<PutDataLakeSettingsResponse, RusotoError<PutDataLakeSettingsError>>;
async fn register_resource(
&self,
input: RegisterResourceRequest,
) -> Result<RegisterResourceResponse, RusotoError<RegisterResourceError>>;
async fn revoke_permissions(
&self,
input: RevokePermissionsRequest,
) -> Result<RevokePermissionsResponse, RusotoError<RevokePermissionsError>>;
async fn update_resource(
&self,
input: UpdateResourceRequest,
) -> Result<UpdateResourceResponse, RusotoError<UpdateResourceError>>;
}
#[derive(Clone)]
pub struct LakeFormationClient {
client: Client,
region: region::Region,
}
impl LakeFormationClient {
pub fn new(region: region::Region) -> LakeFormationClient {
LakeFormationClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> LakeFormationClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
LakeFormationClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> LakeFormationClient {
LakeFormationClient { client, region }
}
}
#[async_trait]
impl LakeFormation for LakeFormationClient {
async fn batch_grant_permissions(
&self,
input: BatchGrantPermissionsRequest,
) -> Result<BatchGrantPermissionsResponse, RusotoError<BatchGrantPermissionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLakeFormation.BatchGrantPermissions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGrantPermissionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchGrantPermissionsResponse, _>()
}
async fn batch_revoke_permissions(
&self,
input: BatchRevokePermissionsRequest,
) -> Result<BatchRevokePermissionsResponse, RusotoError<BatchRevokePermissionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLakeFormation.BatchRevokePermissions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchRevokePermissionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchRevokePermissionsResponse, _>()
}
async fn deregister_resource(
&self,
input: DeregisterResourceRequest,
) -> Result<DeregisterResourceResponse, RusotoError<DeregisterResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLakeFormation.DeregisterResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeregisterResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeregisterResourceResponse, _>()
}
async fn describe_resource(
&self,
input: DescribeResourceRequest,
) -> Result<DescribeResourceResponse, RusotoError<DescribeResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLakeFormation.DescribeResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeResourceResponse, _>()
}
async fn get_data_lake_settings(
&self,
input: GetDataLakeSettingsRequest,
) -> Result<GetDataLakeSettingsResponse, RusotoError<GetDataLakeSettingsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLakeFormation.GetDataLakeSettings");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDataLakeSettingsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDataLakeSettingsResponse, _>()
}
async fn get_effective_permissions_for_path(
&self,
input: GetEffectivePermissionsForPathRequest,
) -> Result<
GetEffectivePermissionsForPathResponse,
RusotoError<GetEffectivePermissionsForPathError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSLakeFormation.GetEffectivePermissionsForPath",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetEffectivePermissionsForPathError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetEffectivePermissionsForPathResponse, _>()
}
async fn grant_permissions(
&self,
input: GrantPermissionsRequest,
) -> Result<GrantPermissionsResponse, RusotoError<GrantPermissionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLakeFormation.GrantPermissions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GrantPermissionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GrantPermissionsResponse, _>()
}
async fn list_permissions(
&self,
input: ListPermissionsRequest,
) -> Result<ListPermissionsResponse, RusotoError<ListPermissionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLakeFormation.ListPermissions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListPermissionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListPermissionsResponse, _>()
}
async fn list_resources(
&self,
input: ListResourcesRequest,
) -> Result<ListResourcesResponse, RusotoError<ListResourcesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLakeFormation.ListResources");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListResourcesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListResourcesResponse, _>()
}
async fn put_data_lake_settings(
&self,
input: PutDataLakeSettingsRequest,
) -> Result<PutDataLakeSettingsResponse, RusotoError<PutDataLakeSettingsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLakeFormation.PutDataLakeSettings");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutDataLakeSettingsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<PutDataLakeSettingsResponse, _>()
}
async fn register_resource(
&self,
input: RegisterResourceRequest,
) -> Result<RegisterResourceResponse, RusotoError<RegisterResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLakeFormation.RegisterResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RegisterResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RegisterResourceResponse, _>()
}
async fn revoke_permissions(
&self,
input: RevokePermissionsRequest,
) -> Result<RevokePermissionsResponse, RusotoError<RevokePermissionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLakeFormation.RevokePermissions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RevokePermissionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RevokePermissionsResponse, _>()
}
async fn update_resource(
&self,
input: UpdateResourceRequest,
) -> Result<UpdateResourceResponse, RusotoError<UpdateResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLakeFormation.UpdateResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateResourceResponse, _>()
}
}