com.amazonaws.services.securitylake.AmazonSecurityLakeAsyncClient Maven / Gradle / Ivy
/*
* 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.securitylake;
import javax.annotation.Generated;
import com.amazonaws.services.securitylake.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import java.util.concurrent.ExecutorService;
/**
* Client for accessing Amazon Security Lake asynchronously. Each asynchronous method will return a Java Future object
* representing the asynchronous operation; overloads which accept an {@code AsyncHandler} can be used to receive
* notification when an asynchronous operation completes.
*
*
* Amazon Security Lake is a fully managed security data lake service. You can use Security Lake to automatically
* centralize security data from cloud, on-premises, and custom sources into a data lake that's stored in your Amazon
* Web Services account. Amazon Web Services Organizations is an account management service that lets you consolidate
* multiple Amazon Web Services accounts into an organization that you create and centrally manage. With Organizations,
* you can create member accounts and invite existing accounts to join your organization. Security Lake helps you
* analyze security data for a more complete understanding of your security posture across the entire organization. It
* can also help you improve the protection of your workloads, applications, and data.
*
*
* The data lake is backed by Amazon Simple Storage Service (Amazon S3) buckets, and you retain ownership over your
* data.
*
*
* Amazon Security Lake integrates with CloudTrail, a service that provides a record of actions taken by a user, role,
* or an Amazon Web Services service. In Security Lake, CloudTrail captures API calls for Security Lake as events. The
* calls captured include calls from the Security Lake console and code calls to the Security Lake API operations. If
* you create a trail, you can enable continuous delivery of CloudTrail events to an Amazon S3 bucket, including events
* for Security Lake. If you don't configure a trail, you can still view the most recent events in the CloudTrail
* console in Event history. Using the information collected by CloudTrail you can determine the request that was made
* to Security Lake, the IP address from which the request was made, who made the request, when it was made, and
* additional details. To learn more about Security Lake information in CloudTrail, see the Amazon Security Lake
* User Guide.
*
*
* Security Lake automates the collection of security-related log and event data from integrated Amazon Web Services and
* third-party services. It also helps you manage the lifecycle of data with customizable retention and replication
* settings. Security Lake converts ingested data into Apache Parquet format and a standard open-source schema called
* the Open Cybersecurity Schema Framework (OCSF).
*
*
* Other Amazon Web Services and third-party services can subscribe to the data that's stored in Security Lake for
* incident response and security data analytics.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonSecurityLakeAsyncClient extends AmazonSecurityLakeClient implements AmazonSecurityLakeAsync {
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
private final java.util.concurrent.ExecutorService executorService;
public static AmazonSecurityLakeAsyncClientBuilder asyncBuilder() {
return AmazonSecurityLakeAsyncClientBuilder.standard();
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Security Lake using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AmazonSecurityLakeAsyncClient(AwsAsyncClientParams asyncClientParams) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on Amazon Security Lake using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AmazonSecurityLakeAsyncClient(AwsAsyncClientParams asyncClientParams, boolean endpointDiscoveryEnabled) {
super(asyncClientParams, endpointDiscoveryEnabled);
this.executorService = asyncClientParams.getExecutor();
}
/**
* Returns the executor service used by this client to execute async requests.
*
* @return The executor service used by this client to execute async requests.
*/
public ExecutorService getExecutorService() {
return executorService;
}
@Override
public java.util.concurrent.Future createAwsLogSourceAsync(CreateAwsLogSourceRequest request) {
return createAwsLogSourceAsync(request, null);
}
@Override
public java.util.concurrent.Future createAwsLogSourceAsync(final CreateAwsLogSourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateAwsLogSourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateAwsLogSourceResult call() throws Exception {
CreateAwsLogSourceResult result = null;
try {
result = executeCreateAwsLogSource(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createCustomLogSourceAsync(CreateCustomLogSourceRequest request) {
return createCustomLogSourceAsync(request, null);
}
@Override
public java.util.concurrent.Future createCustomLogSourceAsync(final CreateCustomLogSourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateCustomLogSourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateCustomLogSourceResult call() throws Exception {
CreateCustomLogSourceResult result = null;
try {
result = executeCreateCustomLogSource(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createDataLakeAsync(CreateDataLakeRequest request) {
return createDataLakeAsync(request, null);
}
@Override
public java.util.concurrent.Future createDataLakeAsync(final CreateDataLakeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateDataLakeRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateDataLakeResult call() throws Exception {
CreateDataLakeResult result = null;
try {
result = executeCreateDataLake(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createDataLakeExceptionSubscriptionAsync(
CreateDataLakeExceptionSubscriptionRequest request) {
return createDataLakeExceptionSubscriptionAsync(request, null);
}
@Override
public java.util.concurrent.Future createDataLakeExceptionSubscriptionAsync(
final CreateDataLakeExceptionSubscriptionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateDataLakeExceptionSubscriptionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateDataLakeExceptionSubscriptionResult call() throws Exception {
CreateDataLakeExceptionSubscriptionResult result = null;
try {
result = executeCreateDataLakeExceptionSubscription(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createDataLakeOrganizationConfigurationAsync(
CreateDataLakeOrganizationConfigurationRequest request) {
return createDataLakeOrganizationConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future createDataLakeOrganizationConfigurationAsync(
final CreateDataLakeOrganizationConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateDataLakeOrganizationConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateDataLakeOrganizationConfigurationResult call() throws Exception {
CreateDataLakeOrganizationConfigurationResult result = null;
try {
result = executeCreateDataLakeOrganizationConfiguration(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createSubscriberAsync(CreateSubscriberRequest request) {
return createSubscriberAsync(request, null);
}
@Override
public java.util.concurrent.Future createSubscriberAsync(final CreateSubscriberRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateSubscriberRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateSubscriberResult call() throws Exception {
CreateSubscriberResult result = null;
try {
result = executeCreateSubscriber(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future createSubscriberNotificationAsync(CreateSubscriberNotificationRequest request) {
return createSubscriberNotificationAsync(request, null);
}
@Override
public java.util.concurrent.Future createSubscriberNotificationAsync(final CreateSubscriberNotificationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateSubscriberNotificationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateSubscriberNotificationResult call() throws Exception {
CreateSubscriberNotificationResult result = null;
try {
result = executeCreateSubscriberNotification(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteAwsLogSourceAsync(DeleteAwsLogSourceRequest request) {
return deleteAwsLogSourceAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAwsLogSourceAsync(final DeleteAwsLogSourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteAwsLogSourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAwsLogSourceResult call() throws Exception {
DeleteAwsLogSourceResult result = null;
try {
result = executeDeleteAwsLogSource(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteCustomLogSourceAsync(DeleteCustomLogSourceRequest request) {
return deleteCustomLogSourceAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteCustomLogSourceAsync(final DeleteCustomLogSourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteCustomLogSourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteCustomLogSourceResult call() throws Exception {
DeleteCustomLogSourceResult result = null;
try {
result = executeDeleteCustomLogSource(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteDataLakeAsync(DeleteDataLakeRequest request) {
return deleteDataLakeAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDataLakeAsync(final DeleteDataLakeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteDataLakeRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDataLakeResult call() throws Exception {
DeleteDataLakeResult result = null;
try {
result = executeDeleteDataLake(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteDataLakeExceptionSubscriptionAsync(
DeleteDataLakeExceptionSubscriptionRequest request) {
return deleteDataLakeExceptionSubscriptionAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDataLakeExceptionSubscriptionAsync(
final DeleteDataLakeExceptionSubscriptionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteDataLakeExceptionSubscriptionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDataLakeExceptionSubscriptionResult call() throws Exception {
DeleteDataLakeExceptionSubscriptionResult result = null;
try {
result = executeDeleteDataLakeExceptionSubscription(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteDataLakeOrganizationConfigurationAsync(
DeleteDataLakeOrganizationConfigurationRequest request) {
return deleteDataLakeOrganizationConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteDataLakeOrganizationConfigurationAsync(
final DeleteDataLakeOrganizationConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteDataLakeOrganizationConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteDataLakeOrganizationConfigurationResult call() throws Exception {
DeleteDataLakeOrganizationConfigurationResult result = null;
try {
result = executeDeleteDataLakeOrganizationConfiguration(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteSubscriberAsync(DeleteSubscriberRequest request) {
return deleteSubscriberAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteSubscriberAsync(final DeleteSubscriberRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteSubscriberRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteSubscriberResult call() throws Exception {
DeleteSubscriberResult result = null;
try {
result = executeDeleteSubscriber(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deleteSubscriberNotificationAsync(DeleteSubscriberNotificationRequest request) {
return deleteSubscriberNotificationAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteSubscriberNotificationAsync(final DeleteSubscriberNotificationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteSubscriberNotificationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteSubscriberNotificationResult call() throws Exception {
DeleteSubscriberNotificationResult result = null;
try {
result = executeDeleteSubscriberNotification(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future deregisterDataLakeDelegatedAdministratorAsync(
DeregisterDataLakeDelegatedAdministratorRequest request) {
return deregisterDataLakeDelegatedAdministratorAsync(request, null);
}
@Override
public java.util.concurrent.Future deregisterDataLakeDelegatedAdministratorAsync(
final DeregisterDataLakeDelegatedAdministratorRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeregisterDataLakeDelegatedAdministratorRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeregisterDataLakeDelegatedAdministratorResult call() throws Exception {
DeregisterDataLakeDelegatedAdministratorResult result = null;
try {
result = executeDeregisterDataLakeDelegatedAdministrator(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getDataLakeExceptionSubscriptionAsync(
GetDataLakeExceptionSubscriptionRequest request) {
return getDataLakeExceptionSubscriptionAsync(request, null);
}
@Override
public java.util.concurrent.Future getDataLakeExceptionSubscriptionAsync(
final GetDataLakeExceptionSubscriptionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetDataLakeExceptionSubscriptionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetDataLakeExceptionSubscriptionResult call() throws Exception {
GetDataLakeExceptionSubscriptionResult result = null;
try {
result = executeGetDataLakeExceptionSubscription(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getDataLakeOrganizationConfigurationAsync(
GetDataLakeOrganizationConfigurationRequest request) {
return getDataLakeOrganizationConfigurationAsync(request, null);
}
@Override
public java.util.concurrent.Future getDataLakeOrganizationConfigurationAsync(
final GetDataLakeOrganizationConfigurationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetDataLakeOrganizationConfigurationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetDataLakeOrganizationConfigurationResult call() throws Exception {
GetDataLakeOrganizationConfigurationResult result = null;
try {
result = executeGetDataLakeOrganizationConfiguration(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getDataLakeSourcesAsync(GetDataLakeSourcesRequest request) {
return getDataLakeSourcesAsync(request, null);
}
@Override
public java.util.concurrent.Future getDataLakeSourcesAsync(final GetDataLakeSourcesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetDataLakeSourcesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetDataLakeSourcesResult call() throws Exception {
GetDataLakeSourcesResult result = null;
try {
result = executeGetDataLakeSources(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future getSubscriberAsync(GetSubscriberRequest request) {
return getSubscriberAsync(request, null);
}
@Override
public java.util.concurrent.Future getSubscriberAsync(final GetSubscriberRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetSubscriberRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetSubscriberResult call() throws Exception {
GetSubscriberResult result = null;
try {
result = executeGetSubscriber(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listDataLakeExceptionsAsync(ListDataLakeExceptionsRequest request) {
return listDataLakeExceptionsAsync(request, null);
}
@Override
public java.util.concurrent.Future listDataLakeExceptionsAsync(final ListDataLakeExceptionsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListDataLakeExceptionsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListDataLakeExceptionsResult call() throws Exception {
ListDataLakeExceptionsResult result = null;
try {
result = executeListDataLakeExceptions(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listDataLakesAsync(ListDataLakesRequest request) {
return listDataLakesAsync(request, null);
}
@Override
public java.util.concurrent.Future listDataLakesAsync(final ListDataLakesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListDataLakesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListDataLakesResult call() throws Exception {
ListDataLakesResult result = null;
try {
result = executeListDataLakes(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listLogSourcesAsync(ListLogSourcesRequest request) {
return listLogSourcesAsync(request, null);
}
@Override
public java.util.concurrent.Future listLogSourcesAsync(final ListLogSourcesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListLogSourcesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListLogSourcesResult call() throws Exception {
ListLogSourcesResult result = null;
try {
result = executeListLogSources(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listSubscribersAsync(ListSubscribersRequest request) {
return listSubscribersAsync(request, null);
}
@Override
public java.util.concurrent.Future listSubscribersAsync(final ListSubscribersRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListSubscribersRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListSubscribersResult call() throws Exception {
ListSubscribersResult result = null;
try {
result = executeListSubscribers(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(ListTagsForResourceRequest request) {
return listTagsForResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future listTagsForResourceAsync(final ListTagsForResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListTagsForResourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTagsForResourceResult call() throws Exception {
ListTagsForResourceResult result = null;
try {
result = executeListTagsForResource(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future registerDataLakeDelegatedAdministratorAsync(
RegisterDataLakeDelegatedAdministratorRequest request) {
return registerDataLakeDelegatedAdministratorAsync(request, null);
}
@Override
public java.util.concurrent.Future registerDataLakeDelegatedAdministratorAsync(
final RegisterDataLakeDelegatedAdministratorRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RegisterDataLakeDelegatedAdministratorRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RegisterDataLakeDelegatedAdministratorResult call() throws Exception {
RegisterDataLakeDelegatedAdministratorResult result = null;
try {
result = executeRegisterDataLakeDelegatedAdministrator(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future tagResourceAsync(TagResourceRequest request) {
return tagResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future tagResourceAsync(final TagResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final TagResourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public TagResourceResult call() throws Exception {
TagResourceResult result = null;
try {
result = executeTagResource(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future untagResourceAsync(UntagResourceRequest request) {
return untagResourceAsync(request, null);
}
@Override
public java.util.concurrent.Future untagResourceAsync(final UntagResourceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UntagResourceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UntagResourceResult call() throws Exception {
UntagResourceResult result = null;
try {
result = executeUntagResource(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateDataLakeAsync(UpdateDataLakeRequest request) {
return updateDataLakeAsync(request, null);
}
@Override
public java.util.concurrent.Future updateDataLakeAsync(final UpdateDataLakeRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateDataLakeRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateDataLakeResult call() throws Exception {
UpdateDataLakeResult result = null;
try {
result = executeUpdateDataLake(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateDataLakeExceptionSubscriptionAsync(
UpdateDataLakeExceptionSubscriptionRequest request) {
return updateDataLakeExceptionSubscriptionAsync(request, null);
}
@Override
public java.util.concurrent.Future updateDataLakeExceptionSubscriptionAsync(
final UpdateDataLakeExceptionSubscriptionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateDataLakeExceptionSubscriptionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateDataLakeExceptionSubscriptionResult call() throws Exception {
UpdateDataLakeExceptionSubscriptionResult result = null;
try {
result = executeUpdateDataLakeExceptionSubscription(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateSubscriberAsync(UpdateSubscriberRequest request) {
return updateSubscriberAsync(request, null);
}
@Override
public java.util.concurrent.Future updateSubscriberAsync(final UpdateSubscriberRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateSubscriberRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateSubscriberResult call() throws Exception {
UpdateSubscriberResult result = null;
try {
result = executeUpdateSubscriber(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
@Override
public java.util.concurrent.Future updateSubscriberNotificationAsync(UpdateSubscriberNotificationRequest request) {
return updateSubscriberNotificationAsync(request, null);
}
@Override
public java.util.concurrent.Future updateSubscriberNotificationAsync(final UpdateSubscriberNotificationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateSubscriberNotificationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateSubscriberNotificationResult call() throws Exception {
UpdateSubscriberNotificationResult result = null;
try {
result = executeUpdateSubscriberNotification(finalRequest);
} catch (Exception ex) {
if (asyncHandler != null) {
asyncHandler.onError(ex);
}
throw ex;
}
if (asyncHandler != null) {
asyncHandler.onSuccess(finalRequest, result);
}
return result;
}
});
}
/**
* Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending
* asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should
* call {@code getExecutorService().shutdown()} followed by {@code getExecutorService().awaitTermination()} prior to
* calling this method.
*/
@Override
public void shutdown() {
super.shutdown();
executorService.shutdownNow();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy