com.amazonaws.services.paymentcryptography.AWSPaymentCryptographyAsyncClient 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.paymentcryptography;
import javax.annotation.Generated;
import com.amazonaws.services.paymentcryptography.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import java.util.concurrent.ExecutorService;
/**
* Client for accessing Payment Cryptography Control Plane 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 Web Services Payment Cryptography Control Plane APIs manage encryption keys for use during payment-related
* cryptographic operations. You can create, import, export, share, manage, and delete keys. You can also manage
* Identity and Access Management (IAM) policies for keys. For more information, see Identity and access
* management in the Amazon Web Services Payment Cryptography User Guide.
*
*
* To use encryption keys for payment-related transaction processing and associated cryptographic operations, you use
* the Amazon Web
* Services Payment Cryptography Data Plane. You can perform actions like encrypt, decrypt, generate, and verify
* payment-related data.
*
*
* All Amazon Web Services Payment Cryptography API calls must be signed and transmitted using Transport Layer Security
* (TLS). We recommend you always use the latest supported TLS version for logging API requests.
*
*
* Amazon Web Services Payment Cryptography supports CloudTrail for control plane operations, a service that logs Amazon
* Web Services API calls and related events for your Amazon Web Services account and delivers them to an Amazon S3
* bucket you specify. By using the information collected by CloudTrail, you can determine what requests were made to
* Amazon Web Services Payment Cryptography, who made the request, when it was made, and so on. If you don't configure a
* trail, you can still view the most recent events in the CloudTrail console. For more information, see the CloudTrail User Guide.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSPaymentCryptographyAsyncClient extends AWSPaymentCryptographyClient implements AWSPaymentCryptographyAsync {
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
private final java.util.concurrent.ExecutorService executorService;
public static AWSPaymentCryptographyAsyncClientBuilder asyncBuilder() {
return AWSPaymentCryptographyAsyncClientBuilder.standard();
}
/**
* Constructs a new asynchronous client to invoke service methods on Payment Cryptography Control Plane using the
* specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AWSPaymentCryptographyAsyncClient(AwsAsyncClientParams asyncClientParams) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on Payment Cryptography Control Plane using the
* specified parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AWSPaymentCryptographyAsyncClient(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 createAliasAsync(CreateAliasRequest request) {
return createAliasAsync(request, null);
}
@Override
public java.util.concurrent.Future createAliasAsync(final CreateAliasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateAliasRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateAliasResult call() throws Exception {
CreateAliasResult result = null;
try {
result = executeCreateAlias(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 createKeyAsync(CreateKeyRequest request) {
return createKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future createKeyAsync(final CreateKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateKeyResult call() throws Exception {
CreateKeyResult result = null;
try {
result = executeCreateKey(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 deleteAliasAsync(DeleteAliasRequest request) {
return deleteAliasAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteAliasAsync(final DeleteAliasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteAliasRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteAliasResult call() throws Exception {
DeleteAliasResult result = null;
try {
result = executeDeleteAlias(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 deleteKeyAsync(DeleteKeyRequest request) {
return deleteKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteKeyAsync(final DeleteKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteKeyResult call() throws Exception {
DeleteKeyResult result = null;
try {
result = executeDeleteKey(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 exportKeyAsync(ExportKeyRequest request) {
return exportKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future exportKeyAsync(final ExportKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ExportKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ExportKeyResult call() throws Exception {
ExportKeyResult result = null;
try {
result = executeExportKey(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 getAliasAsync(GetAliasRequest request) {
return getAliasAsync(request, null);
}
@Override
public java.util.concurrent.Future getAliasAsync(final GetAliasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetAliasRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetAliasResult call() throws Exception {
GetAliasResult result = null;
try {
result = executeGetAlias(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 getKeyAsync(GetKeyRequest request) {
return getKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future getKeyAsync(final GetKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetKeyResult call() throws Exception {
GetKeyResult result = null;
try {
result = executeGetKey(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 getParametersForExportAsync(GetParametersForExportRequest request) {
return getParametersForExportAsync(request, null);
}
@Override
public java.util.concurrent.Future getParametersForExportAsync(final GetParametersForExportRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetParametersForExportRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetParametersForExportResult call() throws Exception {
GetParametersForExportResult result = null;
try {
result = executeGetParametersForExport(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 getParametersForImportAsync(GetParametersForImportRequest request) {
return getParametersForImportAsync(request, null);
}
@Override
public java.util.concurrent.Future getParametersForImportAsync(final GetParametersForImportRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetParametersForImportRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetParametersForImportResult call() throws Exception {
GetParametersForImportResult result = null;
try {
result = executeGetParametersForImport(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 getPublicKeyCertificateAsync(GetPublicKeyCertificateRequest request) {
return getPublicKeyCertificateAsync(request, null);
}
@Override
public java.util.concurrent.Future getPublicKeyCertificateAsync(final GetPublicKeyCertificateRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetPublicKeyCertificateRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetPublicKeyCertificateResult call() throws Exception {
GetPublicKeyCertificateResult result = null;
try {
result = executeGetPublicKeyCertificate(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 importKeyAsync(ImportKeyRequest request) {
return importKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future importKeyAsync(final ImportKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ImportKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ImportKeyResult call() throws Exception {
ImportKeyResult result = null;
try {
result = executeImportKey(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 listAliasesAsync(ListAliasesRequest request) {
return listAliasesAsync(request, null);
}
@Override
public java.util.concurrent.Future listAliasesAsync(final ListAliasesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListAliasesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListAliasesResult call() throws Exception {
ListAliasesResult result = null;
try {
result = executeListAliases(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 listKeysAsync(ListKeysRequest request) {
return listKeysAsync(request, null);
}
@Override
public java.util.concurrent.Future listKeysAsync(final ListKeysRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListKeysRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListKeysResult call() throws Exception {
ListKeysResult result = null;
try {
result = executeListKeys(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 restoreKeyAsync(RestoreKeyRequest request) {
return restoreKeyAsync(request, null);
}
@Override
public java.util.concurrent.Future restoreKeyAsync(final RestoreKeyRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RestoreKeyRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RestoreKeyResult call() throws Exception {
RestoreKeyResult result = null;
try {
result = executeRestoreKey(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 startKeyUsageAsync(StartKeyUsageRequest request) {
return startKeyUsageAsync(request, null);
}
@Override
public java.util.concurrent.Future startKeyUsageAsync(final StartKeyUsageRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final StartKeyUsageRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public StartKeyUsageResult call() throws Exception {
StartKeyUsageResult result = null;
try {
result = executeStartKeyUsage(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 stopKeyUsageAsync(StopKeyUsageRequest request) {
return stopKeyUsageAsync(request, null);
}
@Override
public java.util.concurrent.Future stopKeyUsageAsync(final StopKeyUsageRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final StopKeyUsageRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public StopKeyUsageResult call() throws Exception {
StopKeyUsageResult result = null;
try {
result = executeStopKeyUsage(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 updateAliasAsync(UpdateAliasRequest request) {
return updateAliasAsync(request, null);
}
@Override
public java.util.concurrent.Future updateAliasAsync(final UpdateAliasRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateAliasRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateAliasResult call() throws Exception {
UpdateAliasResult result = null;
try {
result = executeUpdateAlias(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