com.amazonaws.services.lakeformation.AWSLakeFormationClient Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aws-java-sdk-lakeformation Show documentation
Show all versions of aws-java-sdk-lakeformation Show documentation
The AWS Java SDK for AWS Lake Formation module holds the client classes that are used for communicating with AWS Lake Formation Service
/*
* Copyright 2019-2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.lakeformation;
import org.w3c.dom.*;
import java.net.*;
import java.util.*;
import javax.annotation.Generated;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.annotation.SdkInternalApi;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.client.builder.AdvancedConfig;
import com.amazonaws.services.lakeformation.AWSLakeFormationClientBuilder;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.lakeformation.model.*;
import com.amazonaws.services.lakeformation.model.transform.*;
/**
* Client for accessing AWS Lake Formation. All service calls made using this client are blocking, and will not return
* until the service call completes.
*
* Lake Formation
*
* Defines the public endpoint for the Lake Formation service.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSLakeFormationClient extends AmazonWebServiceClient implements AWSLakeFormation {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AWSLakeFormation.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "lakeformation";
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final AdvancedConfig advancedConfig;
private static final com.amazonaws.protocol.json.SdkJsonProtocolFactory protocolFactory = new com.amazonaws.protocol.json.SdkJsonProtocolFactory(
new JsonClientMetadata()
.withProtocolVersion("1.1")
.withSupportsCbor(false)
.withSupportsIon(false)
.withContentTypeOverride("application/json")
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("TransactionCommitInProgressException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.TransactionCommitInProgressExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ConcurrentModificationException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.ConcurrentModificationExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceNotReadyException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.ResourceNotReadyExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceNumberLimitExceededException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.ResourceNumberLimitExceededExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ThrottledException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.ThrottledExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ExpiredException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.ExpiredExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("AccessDeniedException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.AccessDeniedExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InvalidInputException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.InvalidInputExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("AlreadyExistsException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.AlreadyExistsExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("EntityNotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.EntityNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("StatisticsNotReadyYetException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.StatisticsNotReadyYetExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("TransactionCanceledException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.TransactionCanceledExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("GlueEncryptionException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.GlueEncryptionExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("PermissionTypeMismatchException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.PermissionTypeMismatchExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("WorkUnitsNotReadyYetException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.WorkUnitsNotReadyYetExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("TransactionCommittedException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.TransactionCommittedExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("OperationTimeoutException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.OperationTimeoutExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InternalServiceException").withExceptionUnmarshaller(
com.amazonaws.services.lakeformation.model.transform.InternalServiceExceptionUnmarshaller.getInstance()))
.withBaseServiceExceptionClass(com.amazonaws.services.lakeformation.model.AWSLakeFormationException.class));
public static AWSLakeFormationClientBuilder builder() {
return AWSLakeFormationClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on AWS Lake Formation using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AWSLakeFormationClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on AWS Lake Formation using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AWSLakeFormationClient(AwsSyncClientParams clientParams, boolean endpointDiscoveryEnabled) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
this.advancedConfig = clientParams.getAdvancedConfig();
init();
}
private void init() {
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
setEndpoint("lakeformation.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/lakeformation/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/lakeformation/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* Attaches one or more LF-tags to an existing resource.
*
*
* @param addLFTagsToResourceRequest
* @return Result of the AddLFTagsToResource operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @sample AWSLakeFormation.AddLFTagsToResource
* @see AWS API Documentation
*/
@Override
public AddLFTagsToResourceResult addLFTagsToResource(AddLFTagsToResourceRequest request) {
request = beforeClientExecution(request);
return executeAddLFTagsToResource(request);
}
@SdkInternalApi
final AddLFTagsToResourceResult executeAddLFTagsToResource(AddLFTagsToResourceRequest addLFTagsToResourceRequest) {
ExecutionContext executionContext = createExecutionContext(addLFTagsToResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AddLFTagsToResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(addLFTagsToResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AddLFTagsToResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new AddLFTagsToResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Allows a caller to assume an IAM role decorated as the SAML user specified in the SAML assertion included in the
* request. This decoration allows Lake Formation to enforce access policies against the SAML users and groups. This
* API operation requires SAML federation setup in the caller’s account as it can only be called with valid SAML
* assertions. Lake Formation does not scope down the permission of the assumed role. All permissions attached to
* the role via the SAML federation setup will be included in the role session.
*
*
* This decorated role is expected to access data in Amazon S3 by getting temporary access from Lake Formation which
* is authorized via the virtual API GetDataAccess. Therefore, all SAML roles that can be assumed via
* AssumeDecoratedRoleWithSAML must at a minimum include lakeformation:GetDataAccess in
* their role policies. A typical IAM policy attached to such a role would look as follows:
*
*
* @param assumeDecoratedRoleWithSAMLRequest
* @return Result of the AssumeDecoratedRoleWithSAML operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.AssumeDecoratedRoleWithSAML
* @see AWS API Documentation
*/
@Override
public AssumeDecoratedRoleWithSAMLResult assumeDecoratedRoleWithSAML(AssumeDecoratedRoleWithSAMLRequest request) {
request = beforeClientExecution(request);
return executeAssumeDecoratedRoleWithSAML(request);
}
@SdkInternalApi
final AssumeDecoratedRoleWithSAMLResult executeAssumeDecoratedRoleWithSAML(AssumeDecoratedRoleWithSAMLRequest assumeDecoratedRoleWithSAMLRequest) {
ExecutionContext executionContext = createExecutionContext(assumeDecoratedRoleWithSAMLRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new AssumeDecoratedRoleWithSAMLRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(assumeDecoratedRoleWithSAMLRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "AssumeDecoratedRoleWithSAML");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new AssumeDecoratedRoleWithSAMLResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Batch operation to grant permissions to the principal.
*
*
* @param batchGrantPermissionsRequest
* @return Result of the BatchGrantPermissions operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws OperationTimeoutException
* The operation timed out.
* @sample AWSLakeFormation.BatchGrantPermissions
* @see AWS API Documentation
*/
@Override
public BatchGrantPermissionsResult batchGrantPermissions(BatchGrantPermissionsRequest request) {
request = beforeClientExecution(request);
return executeBatchGrantPermissions(request);
}
@SdkInternalApi
final BatchGrantPermissionsResult executeBatchGrantPermissions(BatchGrantPermissionsRequest batchGrantPermissionsRequest) {
ExecutionContext executionContext = createExecutionContext(batchGrantPermissionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new BatchGrantPermissionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(batchGrantPermissionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "BatchGrantPermissions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new BatchGrantPermissionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Batch operation to revoke permissions from the principal.
*
*
* @param batchRevokePermissionsRequest
* @return Result of the BatchRevokePermissions operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws OperationTimeoutException
* The operation timed out.
* @sample AWSLakeFormation.BatchRevokePermissions
* @see AWS API Documentation
*/
@Override
public BatchRevokePermissionsResult batchRevokePermissions(BatchRevokePermissionsRequest request) {
request = beforeClientExecution(request);
return executeBatchRevokePermissions(request);
}
@SdkInternalApi
final BatchRevokePermissionsResult executeBatchRevokePermissions(BatchRevokePermissionsRequest batchRevokePermissionsRequest) {
ExecutionContext executionContext = createExecutionContext(batchRevokePermissionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new BatchRevokePermissionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(batchRevokePermissionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "BatchRevokePermissions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new BatchRevokePermissionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Attempts to cancel the specified transaction. Returns an exception if the transaction was previously committed.
*
*
* @param cancelTransactionRequest
* @return Result of the CancelTransaction operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws TransactionCommittedException
* Contains details about an error where the specified transaction has already been committed and cannot be
* used for UpdateTableObjects.
* @throws TransactionCommitInProgressException
* Contains details about an error related to a transaction commit that was in progress.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @sample AWSLakeFormation.CancelTransaction
* @see AWS API Documentation
*/
@Override
public CancelTransactionResult cancelTransaction(CancelTransactionRequest request) {
request = beforeClientExecution(request);
return executeCancelTransaction(request);
}
@SdkInternalApi
final CancelTransactionResult executeCancelTransaction(CancelTransactionRequest cancelTransactionRequest) {
ExecutionContext executionContext = createExecutionContext(cancelTransactionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CancelTransactionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(cancelTransactionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CancelTransaction");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CancelTransactionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Attempts to commit the specified transaction. Returns an exception if the transaction was previously aborted.
* This API action is idempotent if called multiple times for the same transaction.
*
*
* @param commitTransactionRequest
* @return Result of the CommitTransaction operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws TransactionCanceledException
* Contains details about an error related to a transaction that was cancelled.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @sample AWSLakeFormation.CommitTransaction
* @see AWS API Documentation
*/
@Override
public CommitTransactionResult commitTransaction(CommitTransactionRequest request) {
request = beforeClientExecution(request);
return executeCommitTransaction(request);
}
@SdkInternalApi
final CommitTransactionResult executeCommitTransaction(CommitTransactionRequest commitTransactionRequest) {
ExecutionContext executionContext = createExecutionContext(commitTransactionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CommitTransactionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(commitTransactionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CommitTransaction");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CommitTransactionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a data cell filter to allow one to grant access to certain columns on certain rows.
*
*
* @param createDataCellsFilterRequest
* @return Result of the CreateDataCellsFilter operation returned by the service.
* @throws AlreadyExistsException
* A resource to be created or added already exists.
* @throws InvalidInputException
* The input provided was not valid.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws ResourceNumberLimitExceededException
* A resource numerical limit was exceeded.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.CreateDataCellsFilter
* @see AWS API Documentation
*/
@Override
public CreateDataCellsFilterResult createDataCellsFilter(CreateDataCellsFilterRequest request) {
request = beforeClientExecution(request);
return executeCreateDataCellsFilter(request);
}
@SdkInternalApi
final CreateDataCellsFilterResult executeCreateDataCellsFilter(CreateDataCellsFilterRequest createDataCellsFilterRequest) {
ExecutionContext executionContext = createExecutionContext(createDataCellsFilterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDataCellsFilterRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createDataCellsFilterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDataCellsFilter");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateDataCellsFilterResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an LF-tag with the specified name and values.
*
*
* @param createLFTagRequest
* @return Result of the CreateLFTag operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @throws ResourceNumberLimitExceededException
* A resource numerical limit was exceeded.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.CreateLFTag
* @see AWS API
* Documentation
*/
@Override
public CreateLFTagResult createLFTag(CreateLFTagRequest request) {
request = beforeClientExecution(request);
return executeCreateLFTag(request);
}
@SdkInternalApi
final CreateLFTagResult executeCreateLFTag(CreateLFTagRequest createLFTagRequest) {
ExecutionContext executionContext = createExecutionContext(createLFTagRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateLFTagRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createLFTagRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateLFTag");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateLFTagResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates an IAM Identity Center connection with Lake Formation to allow IAM Identity Center users and groups to
* access Data Catalog resources.
*
*
* @param createLakeFormationIdentityCenterConfigurationRequest
* @return Result of the CreateLakeFormationIdentityCenterConfiguration operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws AlreadyExistsException
* A resource to be created or added already exists.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @sample AWSLakeFormation.CreateLakeFormationIdentityCenterConfiguration
* @see AWS API Documentation
*/
@Override
public CreateLakeFormationIdentityCenterConfigurationResult createLakeFormationIdentityCenterConfiguration(
CreateLakeFormationIdentityCenterConfigurationRequest request) {
request = beforeClientExecution(request);
return executeCreateLakeFormationIdentityCenterConfiguration(request);
}
@SdkInternalApi
final CreateLakeFormationIdentityCenterConfigurationResult executeCreateLakeFormationIdentityCenterConfiguration(
CreateLakeFormationIdentityCenterConfigurationRequest createLakeFormationIdentityCenterConfigurationRequest) {
ExecutionContext executionContext = createExecutionContext(createLakeFormationIdentityCenterConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateLakeFormationIdentityCenterConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createLakeFormationIdentityCenterConfigurationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateLakeFormationIdentityCenterConfiguration");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateLakeFormationIdentityCenterConfigurationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Enforce Lake Formation permissions for the given databases, tables, and principals.
*
*
* @param createLakeFormationOptInRequest
* @return Result of the CreateLakeFormationOptIn operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @sample AWSLakeFormation.CreateLakeFormationOptIn
* @see AWS API Documentation
*/
@Override
public CreateLakeFormationOptInResult createLakeFormationOptIn(CreateLakeFormationOptInRequest request) {
request = beforeClientExecution(request);
return executeCreateLakeFormationOptIn(request);
}
@SdkInternalApi
final CreateLakeFormationOptInResult executeCreateLakeFormationOptIn(CreateLakeFormationOptInRequest createLakeFormationOptInRequest) {
ExecutionContext executionContext = createExecutionContext(createLakeFormationOptInRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateLakeFormationOptInRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createLakeFormationOptInRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateLakeFormationOptIn");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateLakeFormationOptInResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a data cell filter.
*
*
* @param deleteDataCellsFilterRequest
* @return Result of the DeleteDataCellsFilter operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.DeleteDataCellsFilter
* @see AWS API Documentation
*/
@Override
public DeleteDataCellsFilterResult deleteDataCellsFilter(DeleteDataCellsFilterRequest request) {
request = beforeClientExecution(request);
return executeDeleteDataCellsFilter(request);
}
@SdkInternalApi
final DeleteDataCellsFilterResult executeDeleteDataCellsFilter(DeleteDataCellsFilterRequest deleteDataCellsFilterRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDataCellsFilterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDataCellsFilterRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteDataCellsFilterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDataCellsFilter");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteDataCellsFilterResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the specified LF-tag given a key name. If the input parameter tag key was not found, then the operation
* will throw an exception. When you delete an LF-tag, the LFTagPolicy attached to the LF-tag becomes
* invalid. If the deleted LF-tag was still assigned to any resource, the tag policy attach to the deleted LF-tag
* will no longer be applied to the resource.
*
*
* @param deleteLFTagRequest
* @return Result of the DeleteLFTag operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.DeleteLFTag
* @see AWS API
* Documentation
*/
@Override
public DeleteLFTagResult deleteLFTag(DeleteLFTagRequest request) {
request = beforeClientExecution(request);
return executeDeleteLFTag(request);
}
@SdkInternalApi
final DeleteLFTagResult executeDeleteLFTag(DeleteLFTagRequest deleteLFTagRequest) {
ExecutionContext executionContext = createExecutionContext(deleteLFTagRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteLFTagRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteLFTagRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteLFTag");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteLFTagResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an IAM Identity Center connection with Lake Formation.
*
*
* @param deleteLakeFormationIdentityCenterConfigurationRequest
* @return Result of the DeleteLakeFormationIdentityCenterConfiguration operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @sample AWSLakeFormation.DeleteLakeFormationIdentityCenterConfiguration
* @see AWS API Documentation
*/
@Override
public DeleteLakeFormationIdentityCenterConfigurationResult deleteLakeFormationIdentityCenterConfiguration(
DeleteLakeFormationIdentityCenterConfigurationRequest request) {
request = beforeClientExecution(request);
return executeDeleteLakeFormationIdentityCenterConfiguration(request);
}
@SdkInternalApi
final DeleteLakeFormationIdentityCenterConfigurationResult executeDeleteLakeFormationIdentityCenterConfiguration(
DeleteLakeFormationIdentityCenterConfigurationRequest deleteLakeFormationIdentityCenterConfigurationRequest) {
ExecutionContext executionContext = createExecutionContext(deleteLakeFormationIdentityCenterConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteLakeFormationIdentityCenterConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteLakeFormationIdentityCenterConfigurationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteLakeFormationIdentityCenterConfiguration");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteLakeFormationIdentityCenterConfigurationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Remove the Lake Formation permissions enforcement of the given databases, tables, and principals.
*
*
* @param deleteLakeFormationOptInRequest
* @return Result of the DeleteLakeFormationOptIn operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @sample AWSLakeFormation.DeleteLakeFormationOptIn
* @see AWS API Documentation
*/
@Override
public DeleteLakeFormationOptInResult deleteLakeFormationOptIn(DeleteLakeFormationOptInRequest request) {
request = beforeClientExecution(request);
return executeDeleteLakeFormationOptIn(request);
}
@SdkInternalApi
final DeleteLakeFormationOptInResult executeDeleteLakeFormationOptIn(DeleteLakeFormationOptInRequest deleteLakeFormationOptInRequest) {
ExecutionContext executionContext = createExecutionContext(deleteLakeFormationOptInRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteLakeFormationOptInRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteLakeFormationOptInRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteLakeFormationOptIn");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteLakeFormationOptInResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* For a specific governed table, provides a list of Amazon S3 objects that will be written during the current
* transaction and that can be automatically deleted if the transaction is canceled. Without this call, no Amazon S3
* objects are automatically deleted when a transaction cancels.
*
*
* The Glue ETL library function write_dynamic_frame.from_catalog() includes an option to automatically
* call DeleteObjectsOnCancel before writes. For more information, see Rolling Back Amazon S3 Writes.
*
*
* @param deleteObjectsOnCancelRequest
* @return Result of the DeleteObjectsOnCancel operation returned by the service.
* @throws InternalServiceException
* An internal service error occurred.
* @throws InvalidInputException
* The input provided was not valid.
* @throws OperationTimeoutException
* The operation timed out.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws TransactionCommittedException
* Contains details about an error where the specified transaction has already been committed and cannot be
* used for UpdateTableObjects.
* @throws TransactionCanceledException
* Contains details about an error related to a transaction that was cancelled.
* @throws ResourceNotReadyException
* Contains details about an error related to a resource which is not ready for a transaction.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @sample AWSLakeFormation.DeleteObjectsOnCancel
* @see AWS API Documentation
*/
@Override
public DeleteObjectsOnCancelResult deleteObjectsOnCancel(DeleteObjectsOnCancelRequest request) {
request = beforeClientExecution(request);
return executeDeleteObjectsOnCancel(request);
}
@SdkInternalApi
final DeleteObjectsOnCancelResult executeDeleteObjectsOnCancel(DeleteObjectsOnCancelRequest deleteObjectsOnCancelRequest) {
ExecutionContext executionContext = createExecutionContext(deleteObjectsOnCancelRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteObjectsOnCancelRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteObjectsOnCancelRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteObjectsOnCancel");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteObjectsOnCancelResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deregisters the resource as managed by the Data Catalog.
*
*
* When you deregister a path, Lake Formation removes the path from the inline policy attached to your
* service-linked role.
*
*
* @param deregisterResourceRequest
* @return Result of the DeregisterResource operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @sample AWSLakeFormation.DeregisterResource
* @see AWS API Documentation
*/
@Override
public DeregisterResourceResult deregisterResource(DeregisterResourceRequest request) {
request = beforeClientExecution(request);
return executeDeregisterResource(request);
}
@SdkInternalApi
final DeregisterResourceResult executeDeregisterResource(DeregisterResourceRequest deregisterResourceRequest) {
ExecutionContext executionContext = createExecutionContext(deregisterResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeregisterResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deregisterResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeregisterResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeregisterResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves the instance ARN and application ARN for the connection.
*
*
* @param describeLakeFormationIdentityCenterConfigurationRequest
* @return Result of the DescribeLakeFormationIdentityCenterConfiguration operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.DescribeLakeFormationIdentityCenterConfiguration
* @see AWS API Documentation
*/
@Override
public DescribeLakeFormationIdentityCenterConfigurationResult describeLakeFormationIdentityCenterConfiguration(
DescribeLakeFormationIdentityCenterConfigurationRequest request) {
request = beforeClientExecution(request);
return executeDescribeLakeFormationIdentityCenterConfiguration(request);
}
@SdkInternalApi
final DescribeLakeFormationIdentityCenterConfigurationResult executeDescribeLakeFormationIdentityCenterConfiguration(
DescribeLakeFormationIdentityCenterConfigurationRequest describeLakeFormationIdentityCenterConfigurationRequest) {
ExecutionContext executionContext = createExecutionContext(describeLakeFormationIdentityCenterConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeLakeFormationIdentityCenterConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeLakeFormationIdentityCenterConfigurationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeLakeFormationIdentityCenterConfiguration");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeLakeFormationIdentityCenterConfigurationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves the current data access role for the given resource registered in Lake Formation.
*
*
* @param describeResourceRequest
* @return Result of the DescribeResource operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @sample AWSLakeFormation.DescribeResource
* @see AWS
* API Documentation
*/
@Override
public DescribeResourceResult describeResource(DescribeResourceRequest request) {
request = beforeClientExecution(request);
return executeDescribeResource(request);
}
@SdkInternalApi
final DescribeResourceResult executeDescribeResource(DescribeResourceRequest describeResourceRequest) {
ExecutionContext executionContext = createExecutionContext(describeResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the details of a single transaction.
*
*
* @param describeTransactionRequest
* @return Result of the DescribeTransaction operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @sample AWSLakeFormation.DescribeTransaction
* @see AWS API Documentation
*/
@Override
public DescribeTransactionResult describeTransaction(DescribeTransactionRequest request) {
request = beforeClientExecution(request);
return executeDescribeTransaction(request);
}
@SdkInternalApi
final DescribeTransactionResult executeDescribeTransaction(DescribeTransactionRequest describeTransactionRequest) {
ExecutionContext executionContext = createExecutionContext(describeTransactionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeTransactionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeTransactionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeTransaction");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeTransactionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Indicates to the service that the specified transaction is still active and should not be treated as idle and
* aborted.
*
*
* Write transactions that remain idle for a long period are automatically aborted unless explicitly extended.
*
*
* @param extendTransactionRequest
* @return Result of the ExtendTransaction operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws TransactionCommittedException
* Contains details about an error where the specified transaction has already been committed and cannot be
* used for UpdateTableObjects.
* @throws TransactionCanceledException
* Contains details about an error related to a transaction that was cancelled.
* @throws TransactionCommitInProgressException
* Contains details about an error related to a transaction commit that was in progress.
* @sample AWSLakeFormation.ExtendTransaction
* @see AWS API Documentation
*/
@Override
public ExtendTransactionResult extendTransaction(ExtendTransactionRequest request) {
request = beforeClientExecution(request);
return executeExtendTransaction(request);
}
@SdkInternalApi
final ExtendTransactionResult executeExtendTransaction(ExtendTransactionRequest extendTransactionRequest) {
ExecutionContext executionContext = createExecutionContext(extendTransactionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ExtendTransactionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(extendTransactionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ExtendTransaction");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ExtendTransactionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a data cells filter.
*
*
* @param getDataCellsFilterRequest
* @return Result of the GetDataCellsFilter operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @throws OperationTimeoutException
* The operation timed out.
* @throws InternalServiceException
* An internal service error occurred.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.GetDataCellsFilter
* @see AWS API Documentation
*/
@Override
public GetDataCellsFilterResult getDataCellsFilter(GetDataCellsFilterRequest request) {
request = beforeClientExecution(request);
return executeGetDataCellsFilter(request);
}
@SdkInternalApi
final GetDataCellsFilterResult executeGetDataCellsFilter(GetDataCellsFilterRequest getDataCellsFilterRequest) {
ExecutionContext executionContext = createExecutionContext(getDataCellsFilterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetDataCellsFilterRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getDataCellsFilterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetDataCellsFilter");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetDataCellsFilterResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the identity of the invoking principal.
*
*
* @param getDataLakePrincipalRequest
* @return Result of the GetDataLakePrincipal operation returned by the service.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.GetDataLakePrincipal
* @see AWS API Documentation
*/
@Override
public GetDataLakePrincipalResult getDataLakePrincipal(GetDataLakePrincipalRequest request) {
request = beforeClientExecution(request);
return executeGetDataLakePrincipal(request);
}
@SdkInternalApi
final GetDataLakePrincipalResult executeGetDataLakePrincipal(GetDataLakePrincipalRequest getDataLakePrincipalRequest) {
ExecutionContext executionContext = createExecutionContext(getDataLakePrincipalRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetDataLakePrincipalRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getDataLakePrincipalRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetDataLakePrincipal");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetDataLakePrincipalResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves the list of the data lake administrators of a Lake Formation-managed data lake.
*
*
* @param getDataLakeSettingsRequest
* @return Result of the GetDataLakeSettings operation returned by the service.
* @throws InternalServiceException
* An internal service error occurred.
* @throws InvalidInputException
* The input provided was not valid.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @sample AWSLakeFormation.GetDataLakeSettings
* @see AWS API Documentation
*/
@Override
public GetDataLakeSettingsResult getDataLakeSettings(GetDataLakeSettingsRequest request) {
request = beforeClientExecution(request);
return executeGetDataLakeSettings(request);
}
@SdkInternalApi
final GetDataLakeSettingsResult executeGetDataLakeSettings(GetDataLakeSettingsRequest getDataLakeSettingsRequest) {
ExecutionContext executionContext = createExecutionContext(getDataLakeSettingsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetDataLakeSettingsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getDataLakeSettingsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetDataLakeSettings");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetDataLakeSettingsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the Lake Formation permissions for a specified table or database resource located at a path in Amazon S3.
* GetEffectivePermissionsForPath will not return databases and tables if the catalog is encrypted.
*
*
* @param getEffectivePermissionsForPathRequest
* @return Result of the GetEffectivePermissionsForPath operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws OperationTimeoutException
* The operation timed out.
* @throws InternalServiceException
* An internal service error occurred.
* @sample AWSLakeFormation.GetEffectivePermissionsForPath
* @see AWS API Documentation
*/
@Override
public GetEffectivePermissionsForPathResult getEffectivePermissionsForPath(GetEffectivePermissionsForPathRequest request) {
request = beforeClientExecution(request);
return executeGetEffectivePermissionsForPath(request);
}
@SdkInternalApi
final GetEffectivePermissionsForPathResult executeGetEffectivePermissionsForPath(GetEffectivePermissionsForPathRequest getEffectivePermissionsForPathRequest) {
ExecutionContext executionContext = createExecutionContext(getEffectivePermissionsForPathRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetEffectivePermissionsForPathRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(getEffectivePermissionsForPathRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetEffectivePermissionsForPath");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetEffectivePermissionsForPathResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns an LF-tag definition.
*
*
* @param getLFTagRequest
* @return Result of the GetLFTag operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.GetLFTag
* @see AWS API
* Documentation
*/
@Override
public GetLFTagResult getLFTag(GetLFTagRequest request) {
request = beforeClientExecution(request);
return executeGetLFTag(request);
}
@SdkInternalApi
final GetLFTagResult executeGetLFTag(GetLFTagRequest getLFTagRequest) {
ExecutionContext executionContext = createExecutionContext(getLFTagRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetLFTagRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getLFTagRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetLFTag");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetLFTagResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the state of a query previously submitted. Clients are expected to poll GetQueryState to
* monitor the current state of the planning before retrieving the work units. A query state is only visible to the
* principal that made the initial call to StartQueryPlanning.
*
*
* @param getQueryStateRequest
* @return Result of the GetQueryState operation returned by the service.
* @throws InternalServiceException
* An internal service error occurred.
* @throws InvalidInputException
* The input provided was not valid.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.GetQueryState
* @see AWS
* API Documentation
*/
@Override
public GetQueryStateResult getQueryState(GetQueryStateRequest request) {
request = beforeClientExecution(request);
return executeGetQueryState(request);
}
@SdkInternalApi
final GetQueryStateResult executeGetQueryState(GetQueryStateRequest getQueryStateRequest) {
ExecutionContext executionContext = createExecutionContext(getQueryStateRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetQueryStateRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getQueryStateRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetQueryState");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
URI endpointTraitHost = null;
if (!clientConfiguration.isDisableHostPrefixInjection()) {
String hostPrefix = "query-";
String resolvedHostPrefix = String.format("query-");
endpointTraitHost = UriResourcePathUtils.updateUriHost(endpoint, resolvedHostPrefix);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetQueryStateResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext, null, endpointTraitHost);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves statistics on the planning and execution of a query.
*
*
* @param getQueryStatisticsRequest
* @return Result of the GetQueryStatistics operation returned by the service.
* @throws StatisticsNotReadyYetException
* Contains details about an error related to statistics not being ready.
* @throws InternalServiceException
* An internal service error occurred.
* @throws InvalidInputException
* The input provided was not valid.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws ExpiredException
* Contains details about an error where the query request expired.
* @throws ThrottledException
* Contains details about an error where the query request was throttled.
* @sample AWSLakeFormation.GetQueryStatistics
* @see AWS API Documentation
*/
@Override
public GetQueryStatisticsResult getQueryStatistics(GetQueryStatisticsRequest request) {
request = beforeClientExecution(request);
return executeGetQueryStatistics(request);
}
@SdkInternalApi
final GetQueryStatisticsResult executeGetQueryStatistics(GetQueryStatisticsRequest getQueryStatisticsRequest) {
ExecutionContext executionContext = createExecutionContext(getQueryStatisticsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetQueryStatisticsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getQueryStatisticsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetQueryStatistics");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
URI endpointTraitHost = null;
if (!clientConfiguration.isDisableHostPrefixInjection()) {
String hostPrefix = "query-";
String resolvedHostPrefix = String.format("query-");
endpointTraitHost = UriResourcePathUtils.updateUriHost(endpoint, resolvedHostPrefix);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetQueryStatisticsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext, null, endpointTraitHost);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the LF-tags applied to a resource.
*
*
* @param getResourceLFTagsRequest
* @return Result of the GetResourceLFTags operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws GlueEncryptionException
* An encryption operation failed.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.GetResourceLFTags
* @see AWS API Documentation
*/
@Override
public GetResourceLFTagsResult getResourceLFTags(GetResourceLFTagsRequest request) {
request = beforeClientExecution(request);
return executeGetResourceLFTags(request);
}
@SdkInternalApi
final GetResourceLFTagsResult executeGetResourceLFTags(GetResourceLFTagsRequest getResourceLFTagsRequest) {
ExecutionContext executionContext = createExecutionContext(getResourceLFTagsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetResourceLFTagsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getResourceLFTagsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetResourceLFTags");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetResourceLFTagsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the set of Amazon S3 objects that make up the specified governed table. A transaction ID or timestamp can
* be specified for time-travel queries.
*
*
* @param getTableObjectsRequest
* @return Result of the GetTableObjects operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InternalServiceException
* An internal service error occurred.
* @throws InvalidInputException
* The input provided was not valid.
* @throws OperationTimeoutException
* The operation timed out.
* @throws TransactionCommittedException
* Contains details about an error where the specified transaction has already been committed and cannot be
* used for UpdateTableObjects.
* @throws TransactionCanceledException
* Contains details about an error related to a transaction that was cancelled.
* @throws ResourceNotReadyException
* Contains details about an error related to a resource which is not ready for a transaction.
* @sample AWSLakeFormation.GetTableObjects
* @see AWS
* API Documentation
*/
@Override
public GetTableObjectsResult getTableObjects(GetTableObjectsRequest request) {
request = beforeClientExecution(request);
return executeGetTableObjects(request);
}
@SdkInternalApi
final GetTableObjectsResult executeGetTableObjects(GetTableObjectsRequest getTableObjectsRequest) {
ExecutionContext executionContext = createExecutionContext(getTableObjectsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetTableObjectsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getTableObjectsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetTableObjects");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetTableObjectsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* This API is identical to GetTemporaryTableCredentials except that this is used when the target Data
* Catalog resource is of type Partition. Lake Formation restricts the permission of the vended credentials with the
* same scope down policy which restricts access to a single Amazon S3 prefix.
*
*
* @param getTemporaryGluePartitionCredentialsRequest
* @return Result of the GetTemporaryGluePartitionCredentials operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws PermissionTypeMismatchException
* The engine does not support filtering data based on the enforced permissions. For example, if you call
* the GetTemporaryGlueTableCredentials operation with SupportedPermissionType
* equal to ColumnPermission, but cell-level permissions exist on the table, this exception is
* thrown.
* @sample AWSLakeFormation.GetTemporaryGluePartitionCredentials
* @see AWS API Documentation
*/
@Override
public GetTemporaryGluePartitionCredentialsResult getTemporaryGluePartitionCredentials(GetTemporaryGluePartitionCredentialsRequest request) {
request = beforeClientExecution(request);
return executeGetTemporaryGluePartitionCredentials(request);
}
@SdkInternalApi
final GetTemporaryGluePartitionCredentialsResult executeGetTemporaryGluePartitionCredentials(
GetTemporaryGluePartitionCredentialsRequest getTemporaryGluePartitionCredentialsRequest) {
ExecutionContext executionContext = createExecutionContext(getTemporaryGluePartitionCredentialsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetTemporaryGluePartitionCredentialsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(getTemporaryGluePartitionCredentialsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetTemporaryGluePartitionCredentials");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetTemporaryGluePartitionCredentialsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Allows a caller in a secure environment to assume a role with permission to access Amazon S3. In order to vend
* such credentials, Lake Formation assumes the role associated with a registered location, for example an Amazon S3
* bucket, with a scope down policy which restricts the access to a single prefix.
*
*
* @param getTemporaryGlueTableCredentialsRequest
* @return Result of the GetTemporaryGlueTableCredentials operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws PermissionTypeMismatchException
* The engine does not support filtering data based on the enforced permissions. For example, if you call
* the GetTemporaryGlueTableCredentials operation with SupportedPermissionType
* equal to ColumnPermission, but cell-level permissions exist on the table, this exception is
* thrown.
* @sample AWSLakeFormation.GetTemporaryGlueTableCredentials
* @see AWS API Documentation
*/
@Override
public GetTemporaryGlueTableCredentialsResult getTemporaryGlueTableCredentials(GetTemporaryGlueTableCredentialsRequest request) {
request = beforeClientExecution(request);
return executeGetTemporaryGlueTableCredentials(request);
}
@SdkInternalApi
final GetTemporaryGlueTableCredentialsResult executeGetTemporaryGlueTableCredentials(
GetTemporaryGlueTableCredentialsRequest getTemporaryGlueTableCredentialsRequest) {
ExecutionContext executionContext = createExecutionContext(getTemporaryGlueTableCredentialsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetTemporaryGlueTableCredentialsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(getTemporaryGlueTableCredentialsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetTemporaryGlueTableCredentials");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new GetTemporaryGlueTableCredentialsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the work units resulting from the query. Work units can be executed in any order and in parallel.
*
*
* @param getWorkUnitResultsRequest
* @return Result of the GetWorkUnitResults operation returned by the service.
* @throws InternalServiceException
* An internal service error occurred.
* @throws InvalidInputException
* The input provided was not valid.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws ExpiredException
* Contains details about an error where the query request expired.
* @throws ThrottledException
* Contains details about an error where the query request was throttled.
* @sample AWSLakeFormation.GetWorkUnitResults
* @see AWS API Documentation
*/
@Override
public GetWorkUnitResultsResult getWorkUnitResults(GetWorkUnitResultsRequest request) {
request = beforeClientExecution(request);
return executeGetWorkUnitResults(request);
}
@SdkInternalApi
final GetWorkUnitResultsResult executeGetWorkUnitResults(GetWorkUnitResultsRequest getWorkUnitResultsRequest) {
ExecutionContext executionContext = createExecutionContext(getWorkUnitResultsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetWorkUnitResultsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getWorkUnitResultsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetWorkUnitResults");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
URI endpointTraitHost = null;
if (!clientConfiguration.isDisableHostPrefixInjection()) {
String hostPrefix = "data-";
String resolvedHostPrefix = String.format("data-");
endpointTraitHost = UriResourcePathUtils.updateUriHost(endpoint, resolvedHostPrefix);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(false).withHasStreamingSuccessResponse(true), new GetWorkUnitResultsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext, null, endpointTraitHost);
request.addHandlerContext(HandlerContextKey.HAS_STREAMING_OUTPUT, Boolean.TRUE);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves the work units generated by the StartQueryPlanning operation.
*
*
* @param getWorkUnitsRequest
* @return Result of the GetWorkUnits operation returned by the service.
* @throws WorkUnitsNotReadyYetException
* Contains details about an error related to work units not being ready.
* @throws InternalServiceException
* An internal service error occurred.
* @throws InvalidInputException
* The input provided was not valid.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws ExpiredException
* Contains details about an error where the query request expired.
* @sample AWSLakeFormation.GetWorkUnits
* @see AWS API
* Documentation
*/
@Override
public GetWorkUnitsResult getWorkUnits(GetWorkUnitsRequest request) {
request = beforeClientExecution(request);
return executeGetWorkUnits(request);
}
@SdkInternalApi
final GetWorkUnitsResult executeGetWorkUnits(GetWorkUnitsRequest getWorkUnitsRequest) {
ExecutionContext executionContext = createExecutionContext(getWorkUnitsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GetWorkUnitsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(getWorkUnitsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GetWorkUnits");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
URI endpointTraitHost = null;
if (!clientConfiguration.isDisableHostPrefixInjection()) {
String hostPrefix = "query-";
String resolvedHostPrefix = String.format("query-");
endpointTraitHost = UriResourcePathUtils.updateUriHost(endpoint, resolvedHostPrefix);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GetWorkUnitsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext, null, endpointTraitHost);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Grants permissions to the principal to access metadata in the Data Catalog and data organized in underlying data
* storage such as Amazon S3.
*
*
* For information about permissions, see Security and Access Control
* to Metadata and Data.
*
*
* @param grantPermissionsRequest
* @return Result of the GrantPermissions operation returned by the service.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @sample AWSLakeFormation.GrantPermissions
* @see AWS
* API Documentation
*/
@Override
public GrantPermissionsResult grantPermissions(GrantPermissionsRequest request) {
request = beforeClientExecution(request);
return executeGrantPermissions(request);
}
@SdkInternalApi
final GrantPermissionsResult executeGrantPermissions(GrantPermissionsRequest grantPermissionsRequest) {
ExecutionContext executionContext = createExecutionContext(grantPermissionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new GrantPermissionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(grantPermissionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "GrantPermissions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new GrantPermissionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists all the data cell filters on a table.
*
*
* @param listDataCellsFilterRequest
* @return Result of the ListDataCellsFilter operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws OperationTimeoutException
* The operation timed out.
* @throws InternalServiceException
* An internal service error occurred.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.ListDataCellsFilter
* @see AWS API Documentation
*/
@Override
public ListDataCellsFilterResult listDataCellsFilter(ListDataCellsFilterRequest request) {
request = beforeClientExecution(request);
return executeListDataCellsFilter(request);
}
@SdkInternalApi
final ListDataCellsFilterResult executeListDataCellsFilter(ListDataCellsFilterRequest listDataCellsFilterRequest) {
ExecutionContext executionContext = createExecutionContext(listDataCellsFilterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListDataCellsFilterRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listDataCellsFilterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListDataCellsFilter");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListDataCellsFilterResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists LF-tags that the requester has permission to view.
*
*
* @param listLFTagsRequest
* @return Result of the ListLFTags operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.ListLFTags
* @see AWS API
* Documentation
*/
@Override
public ListLFTagsResult listLFTags(ListLFTagsRequest request) {
request = beforeClientExecution(request);
return executeListLFTags(request);
}
@SdkInternalApi
final ListLFTagsResult executeListLFTags(ListLFTagsRequest listLFTagsRequest) {
ExecutionContext executionContext = createExecutionContext(listLFTagsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListLFTagsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listLFTagsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListLFTags");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListLFTagsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieve the current list of resources and principals that are opt in to enforce Lake Formation permissions.
*
*
* @param listLakeFormationOptInsRequest
* @return Result of the ListLakeFormationOptIns operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.ListLakeFormationOptIns
* @see AWS API Documentation
*/
@Override
public ListLakeFormationOptInsResult listLakeFormationOptIns(ListLakeFormationOptInsRequest request) {
request = beforeClientExecution(request);
return executeListLakeFormationOptIns(request);
}
@SdkInternalApi
final ListLakeFormationOptInsResult executeListLakeFormationOptIns(ListLakeFormationOptInsRequest listLakeFormationOptInsRequest) {
ExecutionContext executionContext = createExecutionContext(listLakeFormationOptInsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListLakeFormationOptInsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listLakeFormationOptInsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListLakeFormationOptIns");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListLakeFormationOptInsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of the principal permissions on the resource, filtered by the permissions of the caller. For
* example, if you are granted an ALTER permission, you are able to see only the principal permissions for ALTER.
*
*
* This operation returns only those permissions that have been explicitly granted.
*
*
* For information about permissions, see Security and Access Control
* to Metadata and Data.
*
*
* @param listPermissionsRequest
* @return Result of the ListPermissions operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws OperationTimeoutException
* The operation timed out.
* @throws InternalServiceException
* An internal service error occurred.
* @sample AWSLakeFormation.ListPermissions
* @see AWS
* API Documentation
*/
@Override
public ListPermissionsResult listPermissions(ListPermissionsRequest request) {
request = beforeClientExecution(request);
return executeListPermissions(request);
}
@SdkInternalApi
final ListPermissionsResult executeListPermissions(ListPermissionsRequest listPermissionsRequest) {
ExecutionContext executionContext = createExecutionContext(listPermissionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListPermissionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listPermissionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListPermissions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListPermissionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists the resources registered to be managed by the Data Catalog.
*
*
* @param listResourcesRequest
* @return Result of the ListResources operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @sample AWSLakeFormation.ListResources
* @see AWS
* API Documentation
*/
@Override
public ListResourcesResult listResources(ListResourcesRequest request) {
request = beforeClientExecution(request);
return executeListResources(request);
}
@SdkInternalApi
final ListResourcesResult executeListResources(ListResourcesRequest listResourcesRequest) {
ExecutionContext executionContext = createExecutionContext(listResourcesRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListResourcesRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listResourcesRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListResources");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListResourcesResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the configuration of all storage optimizers associated with a specified table.
*
*
* @param listTableStorageOptimizersRequest
* @return Result of the ListTableStorageOptimizers operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws InternalServiceException
* An internal service error occurred.
* @sample AWSLakeFormation.ListTableStorageOptimizers
* @see AWS API Documentation
*/
@Override
public ListTableStorageOptimizersResult listTableStorageOptimizers(ListTableStorageOptimizersRequest request) {
request = beforeClientExecution(request);
return executeListTableStorageOptimizers(request);
}
@SdkInternalApi
final ListTableStorageOptimizersResult executeListTableStorageOptimizers(ListTableStorageOptimizersRequest listTableStorageOptimizersRequest) {
ExecutionContext executionContext = createExecutionContext(listTableStorageOptimizersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTableStorageOptimizersRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listTableStorageOptimizersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTableStorageOptimizers");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListTableStorageOptimizersResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns metadata about transactions and their status. To prevent the response from growing indefinitely, only
* uncommitted transactions and those available for time-travel queries are returned.
*
*
* This operation can help you identify uncommitted transactions or to get information about transactions.
*
*
* @param listTransactionsRequest
* @return Result of the ListTransactions operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @sample AWSLakeFormation.ListTransactions
* @see AWS
* API Documentation
*/
@Override
public ListTransactionsResult listTransactions(ListTransactionsRequest request) {
request = beforeClientExecution(request);
return executeListTransactions(request);
}
@SdkInternalApi
final ListTransactionsResult executeListTransactions(ListTransactionsRequest listTransactionsRequest) {
ExecutionContext executionContext = createExecutionContext(listTransactionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTransactionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listTransactionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTransactions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListTransactionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Sets the list of data lake administrators who have admin privileges on all resources managed by Lake Formation.
* For more information on admin privileges, see Granting Lake
* Formation Permissions.
*
*
* This API replaces the current list of data lake admins with the new list being passed. To add an admin, fetch the
* current list and add the new admin to that list and pass that list in this API.
*
*
* @param putDataLakeSettingsRequest
* @return Result of the PutDataLakeSettings operation returned by the service.
* @throws InternalServiceException
* An internal service error occurred.
* @throws InvalidInputException
* The input provided was not valid.
* @sample AWSLakeFormation.PutDataLakeSettings
* @see AWS API Documentation
*/
@Override
public PutDataLakeSettingsResult putDataLakeSettings(PutDataLakeSettingsRequest request) {
request = beforeClientExecution(request);
return executePutDataLakeSettings(request);
}
@SdkInternalApi
final PutDataLakeSettingsResult executePutDataLakeSettings(PutDataLakeSettingsRequest putDataLakeSettingsRequest) {
ExecutionContext executionContext = createExecutionContext(putDataLakeSettingsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PutDataLakeSettingsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(putDataLakeSettingsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "PutDataLakeSettings");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new PutDataLakeSettingsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Registers the resource as managed by the Data Catalog.
*
*
* To add or update data, Lake Formation needs read/write access to the chosen Amazon S3 path. Choose a role that
* you know has permission to do this, or choose the AWSServiceRoleForLakeFormationDataAccess service-linked role.
* When you register the first Amazon S3 path, the service-linked role and a new inline policy are created on your
* behalf. Lake Formation adds the first path to the inline policy and attaches it to the service-linked role. When
* you register subsequent paths, Lake Formation adds the path to the existing policy.
*
*
* The following request registers a new location and gives Lake Formation permission to use the service-linked role
* to access that location.
*
*
* ResourceArn = arn:aws:s3:::my-bucket UseServiceLinkedRole = true
*
*
* If UseServiceLinkedRole is not set to true, you must provide or set the RoleArn:
*
*
* arn:aws:iam::12345:role/my-data-access-role
*
*
* @param registerResourceRequest
* @return Result of the RegisterResource operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AlreadyExistsException
* A resource to be created or added already exists.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws ResourceNumberLimitExceededException
* A resource numerical limit was exceeded.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.RegisterResource
* @see AWS
* API Documentation
*/
@Override
public RegisterResourceResult registerResource(RegisterResourceRequest request) {
request = beforeClientExecution(request);
return executeRegisterResource(request);
}
@SdkInternalApi
final RegisterResourceResult executeRegisterResource(RegisterResourceRequest registerResourceRequest) {
ExecutionContext executionContext = createExecutionContext(registerResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RegisterResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(registerResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RegisterResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new RegisterResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Removes an LF-tag from the resource. Only database, table, or tableWithColumns resource are allowed. To tag
* columns, use the column inclusion list in tableWithColumns to specify column input.
*
*
* @param removeLFTagsFromResourceRequest
* @return Result of the RemoveLFTagsFromResource operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws GlueEncryptionException
* An encryption operation failed.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @sample AWSLakeFormation.RemoveLFTagsFromResource
* @see AWS API Documentation
*/
@Override
public RemoveLFTagsFromResourceResult removeLFTagsFromResource(RemoveLFTagsFromResourceRequest request) {
request = beforeClientExecution(request);
return executeRemoveLFTagsFromResource(request);
}
@SdkInternalApi
final RemoveLFTagsFromResourceResult executeRemoveLFTagsFromResource(RemoveLFTagsFromResourceRequest removeLFTagsFromResourceRequest) {
ExecutionContext executionContext = createExecutionContext(removeLFTagsFromResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RemoveLFTagsFromResourceRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(removeLFTagsFromResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RemoveLFTagsFromResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new RemoveLFTagsFromResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Revokes permissions to the principal to access metadata in the Data Catalog and data organized in underlying data
* storage such as Amazon S3.
*
*
* @param revokePermissionsRequest
* @return Result of the RevokePermissions operation returned by the service.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @sample AWSLakeFormation.RevokePermissions
* @see AWS API Documentation
*/
@Override
public RevokePermissionsResult revokePermissions(RevokePermissionsRequest request) {
request = beforeClientExecution(request);
return executeRevokePermissions(request);
}
@SdkInternalApi
final RevokePermissionsResult executeRevokePermissions(RevokePermissionsRequest revokePermissionsRequest) {
ExecutionContext executionContext = createExecutionContext(revokePermissionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new RevokePermissionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(revokePermissionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "RevokePermissions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new RevokePermissionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* This operation allows a search on DATABASE resources by TagCondition. This operation is
* used by admins who want to grant user permissions on certain TagConditions. Before making a grant,
* the admin can use SearchDatabasesByTags to find all resources where the given
* TagConditions are valid to verify whether the returned resources can be shared.
*
*
* @param searchDatabasesByLFTagsRequest
* @return Result of the SearchDatabasesByLFTags operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InternalServiceException
* An internal service error occurred.
* @throws InvalidInputException
* The input provided was not valid.
* @throws OperationTimeoutException
* The operation timed out.
* @throws GlueEncryptionException
* An encryption operation failed.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.SearchDatabasesByLFTags
* @see AWS API Documentation
*/
@Override
public SearchDatabasesByLFTagsResult searchDatabasesByLFTags(SearchDatabasesByLFTagsRequest request) {
request = beforeClientExecution(request);
return executeSearchDatabasesByLFTags(request);
}
@SdkInternalApi
final SearchDatabasesByLFTagsResult executeSearchDatabasesByLFTags(SearchDatabasesByLFTagsRequest searchDatabasesByLFTagsRequest) {
ExecutionContext executionContext = createExecutionContext(searchDatabasesByLFTagsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SearchDatabasesByLFTagsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(searchDatabasesByLFTagsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SearchDatabasesByLFTags");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new SearchDatabasesByLFTagsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* This operation allows a search on TABLE resources by LFTags. This will be used by
* admins who want to grant user permissions on certain LF-tags. Before making a grant, the admin can use
* SearchTablesByLFTags to find all resources where the given LFTags are valid to verify
* whether the returned resources can be shared.
*
*
* @param searchTablesByLFTagsRequest
* @return Result of the SearchTablesByLFTags operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InternalServiceException
* An internal service error occurred.
* @throws InvalidInputException
* The input provided was not valid.
* @throws OperationTimeoutException
* The operation timed out.
* @throws GlueEncryptionException
* An encryption operation failed.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.SearchTablesByLFTags
* @see AWS API Documentation
*/
@Override
public SearchTablesByLFTagsResult searchTablesByLFTags(SearchTablesByLFTagsRequest request) {
request = beforeClientExecution(request);
return executeSearchTablesByLFTags(request);
}
@SdkInternalApi
final SearchTablesByLFTagsResult executeSearchTablesByLFTags(SearchTablesByLFTagsRequest searchTablesByLFTagsRequest) {
ExecutionContext executionContext = createExecutionContext(searchTablesByLFTagsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new SearchTablesByLFTagsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(searchTablesByLFTagsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "SearchTablesByLFTags");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new SearchTablesByLFTagsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Submits a request to process a query statement.
*
*
* This operation generates work units that can be retrieved with the GetWorkUnits operation as soon as
* the query state is WORKUNITS_AVAILABLE or FINISHED.
*
*
* @param startQueryPlanningRequest
* @return Result of the StartQueryPlanning operation returned by the service.
* @throws InternalServiceException
* An internal service error occurred.
* @throws InvalidInputException
* The input provided was not valid.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws ThrottledException
* Contains details about an error where the query request was throttled.
* @sample AWSLakeFormation.StartQueryPlanning
* @see AWS API Documentation
*/
@Override
public StartQueryPlanningResult startQueryPlanning(StartQueryPlanningRequest request) {
request = beforeClientExecution(request);
return executeStartQueryPlanning(request);
}
@SdkInternalApi
final StartQueryPlanningResult executeStartQueryPlanning(StartQueryPlanningRequest startQueryPlanningRequest) {
ExecutionContext executionContext = createExecutionContext(startQueryPlanningRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartQueryPlanningRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(startQueryPlanningRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StartQueryPlanning");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
URI endpointTraitHost = null;
if (!clientConfiguration.isDisableHostPrefixInjection()) {
String hostPrefix = "query-";
String resolvedHostPrefix = String.format("query-");
endpointTraitHost = UriResourcePathUtils.updateUriHost(endpoint, resolvedHostPrefix);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new StartQueryPlanningResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext, null, endpointTraitHost);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Starts a new transaction and returns its transaction ID. Transaction IDs are opaque objects that you can use to
* identify a transaction.
*
*
* @param startTransactionRequest
* @return Result of the StartTransaction operation returned by the service.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @sample AWSLakeFormation.StartTransaction
* @see AWS
* API Documentation
*/
@Override
public StartTransactionResult startTransaction(StartTransactionRequest request) {
request = beforeClientExecution(request);
return executeStartTransaction(request);
}
@SdkInternalApi
final StartTransactionResult executeStartTransaction(StartTransactionRequest startTransactionRequest) {
ExecutionContext executionContext = createExecutionContext(startTransactionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartTransactionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(startTransactionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StartTransaction");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new StartTransactionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates a data cell filter.
*
*
* @param updateDataCellsFilterRequest
* @return Result of the UpdateDataCellsFilter operation returned by the service.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @throws InvalidInputException
* The input provided was not valid.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.UpdateDataCellsFilter
* @see AWS API Documentation
*/
@Override
public UpdateDataCellsFilterResult updateDataCellsFilter(UpdateDataCellsFilterRequest request) {
request = beforeClientExecution(request);
return executeUpdateDataCellsFilter(request);
}
@SdkInternalApi
final UpdateDataCellsFilterResult executeUpdateDataCellsFilter(UpdateDataCellsFilterRequest updateDataCellsFilterRequest) {
ExecutionContext executionContext = createExecutionContext(updateDataCellsFilterRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateDataCellsFilterRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateDataCellsFilterRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateDataCellsFilter");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateDataCellsFilterResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the list of possible values for the specified LF-tag key. If the LF-tag does not exist, the operation
* throws an EntityNotFoundException. The values in the delete key values will be deleted from list of possible
* values. If any value in the delete key values is attached to a resource, then API errors out with a 400 Exception
* - "Update not allowed". Untag the attribute before deleting the LF-tag key's value.
*
*
* @param updateLFTagRequest
* @return Result of the UpdateLFTag operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @throws AccessDeniedException
* Access to a resource was denied.
* @sample AWSLakeFormation.UpdateLFTag
* @see AWS API
* Documentation
*/
@Override
public UpdateLFTagResult updateLFTag(UpdateLFTagRequest request) {
request = beforeClientExecution(request);
return executeUpdateLFTag(request);
}
@SdkInternalApi
final UpdateLFTagResult executeUpdateLFTag(UpdateLFTagRequest updateLFTagRequest) {
ExecutionContext executionContext = createExecutionContext(updateLFTagRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateLFTagRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateLFTagRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateLFTag");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateLFTagResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the IAM Identity Center connection parameters.
*
*
* @param updateLakeFormationIdentityCenterConfigurationRequest
* @return Result of the UpdateLakeFormationIdentityCenterConfiguration operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @sample AWSLakeFormation.UpdateLakeFormationIdentityCenterConfiguration
* @see AWS API Documentation
*/
@Override
public UpdateLakeFormationIdentityCenterConfigurationResult updateLakeFormationIdentityCenterConfiguration(
UpdateLakeFormationIdentityCenterConfigurationRequest request) {
request = beforeClientExecution(request);
return executeUpdateLakeFormationIdentityCenterConfiguration(request);
}
@SdkInternalApi
final UpdateLakeFormationIdentityCenterConfigurationResult executeUpdateLakeFormationIdentityCenterConfiguration(
UpdateLakeFormationIdentityCenterConfigurationRequest updateLakeFormationIdentityCenterConfigurationRequest) {
ExecutionContext executionContext = createExecutionContext(updateLakeFormationIdentityCenterConfigurationRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateLakeFormationIdentityCenterConfigurationRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateLakeFormationIdentityCenterConfigurationRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateLakeFormationIdentityCenterConfiguration");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateLakeFormationIdentityCenterConfigurationResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the data access role used for vending access to the given (registered) resource in Lake Formation.
*
*
* @param updateResourceRequest
* @return Result of the UpdateResource operation returned by the service.
* @throws InvalidInputException
* The input provided was not valid.
* @throws InternalServiceException
* An internal service error occurred.
* @throws OperationTimeoutException
* The operation timed out.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @sample AWSLakeFormation.UpdateResource
* @see AWS
* API Documentation
*/
@Override
public UpdateResourceResult updateResource(UpdateResourceRequest request) {
request = beforeClientExecution(request);
return executeUpdateResource(request);
}
@SdkInternalApi
final UpdateResourceResult executeUpdateResource(UpdateResourceRequest updateResourceRequest) {
ExecutionContext executionContext = createExecutionContext(updateResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the manifest of Amazon S3 objects that make up the specified governed table.
*
*
* @param updateTableObjectsRequest
* @return Result of the UpdateTableObjects operation returned by the service.
* @throws InternalServiceException
* An internal service error occurred.
* @throws InvalidInputException
* The input provided was not valid.
* @throws OperationTimeoutException
* The operation timed out.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws TransactionCommittedException
* Contains details about an error where the specified transaction has already been committed and cannot be
* used for UpdateTableObjects.
* @throws TransactionCanceledException
* Contains details about an error related to a transaction that was cancelled.
* @throws TransactionCommitInProgressException
* Contains details about an error related to a transaction commit that was in progress.
* @throws ResourceNotReadyException
* Contains details about an error related to a resource which is not ready for a transaction.
* @throws ConcurrentModificationException
* Two processes are trying to modify a resource simultaneously.
* @sample AWSLakeFormation.UpdateTableObjects
* @see AWS API Documentation
*/
@Override
public UpdateTableObjectsResult updateTableObjects(UpdateTableObjectsRequest request) {
request = beforeClientExecution(request);
return executeUpdateTableObjects(request);
}
@SdkInternalApi
final UpdateTableObjectsResult executeUpdateTableObjects(UpdateTableObjectsRequest updateTableObjectsRequest) {
ExecutionContext executionContext = createExecutionContext(updateTableObjectsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateTableObjectsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateTableObjectsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateTableObjects");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateTableObjectsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the configuration of the storage optimizers for a table.
*
*
* @param updateTableStorageOptimizerRequest
* @return Result of the UpdateTableStorageOptimizer operation returned by the service.
* @throws EntityNotFoundException
* A specified entity does not exist.
* @throws InvalidInputException
* The input provided was not valid.
* @throws AccessDeniedException
* Access to a resource was denied.
* @throws InternalServiceException
* An internal service error occurred.
* @sample AWSLakeFormation.UpdateTableStorageOptimizer
* @see AWS API Documentation
*/
@Override
public UpdateTableStorageOptimizerResult updateTableStorageOptimizer(UpdateTableStorageOptimizerRequest request) {
request = beforeClientExecution(request);
return executeUpdateTableStorageOptimizer(request);
}
@SdkInternalApi
final UpdateTableStorageOptimizerResult executeUpdateTableStorageOptimizer(UpdateTableStorageOptimizerRequest updateTableStorageOptimizerRequest) {
ExecutionContext executionContext = createExecutionContext(updateTableStorageOptimizerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateTableStorageOptimizerRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateTableStorageOptimizerRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LakeFormation");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateTableStorageOptimizer");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateTableStorageOptimizerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
*
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return invoke(request, responseHandler, executionContext, null, null);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI cachedEndpoint, URI uriFromEndpointTrait) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext, cachedEndpoint, uriFromEndpointTrait);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private Response anonymousInvoke(Request request,
HttpResponseHandler> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext, null, null);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private Response doInvoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI discoveredEndpoint, URI uriFromEndpointTrait) {
if (discoveredEndpoint != null) {
request.setEndpoint(discoveredEndpoint);
request.getOriginalRequest().getRequestClientOptions().appendUserAgent("endpoint-discovery");
} else if (uriFromEndpointTrait != null) {
request.setEndpoint(uriFromEndpointTrait);
} else {
request.setEndpoint(endpoint);
}
request.setTimeOffset(timeOffset);
HttpResponseHandler errorResponseHandler = protocolFactory.createErrorResponseHandler(new JsonErrorResponseMetadata());
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
@com.amazonaws.annotation.SdkInternalApi
static com.amazonaws.protocol.json.SdkJsonProtocolFactory getProtocolFactory() {
return protocolFactory;
}
@Override
public void shutdown() {
super.shutdown();
}
}