com.amazonaws.services.servicediscovery.AWSServiceDiscoveryAsyncClient Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aws-java-sdk-servicediscovery Show documentation
Show all versions of aws-java-sdk-servicediscovery Show documentation
The AWS Java SDK for Amazon Route 53 Auto Naming module holds the client classes that are used for communicating with Amazon Route 53 Auto Naming 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.servicediscovery;
import javax.annotation.Generated;
import com.amazonaws.services.servicediscovery.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import java.util.concurrent.ExecutorService;
/**
* Client for accessing ServiceDiscovery 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.
*
* Cloud Map
*
* With Cloud Map, you can configure public DNS, private DNS, or HTTP namespaces that your microservice applications run
* in. When an instance becomes available, you can call the Cloud Map API to register the instance with Cloud Map. For
* public or private DNS namespaces, Cloud Map automatically creates DNS records and an optional health check. Clients
* that submit public or private DNS queries, or HTTP requests, for the service receive an answer that contains up to
* eight healthy records.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSServiceDiscoveryAsyncClient extends AWSServiceDiscoveryClient implements AWSServiceDiscoveryAsync {
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
private final java.util.concurrent.ExecutorService executorService;
public static AWSServiceDiscoveryAsyncClientBuilder asyncBuilder() {
return AWSServiceDiscoveryAsyncClientBuilder.standard();
}
/**
* Constructs a new asynchronous client to invoke service methods on ServiceDiscovery using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AWSServiceDiscoveryAsyncClient(AwsAsyncClientParams asyncClientParams) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on ServiceDiscovery using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AWSServiceDiscoveryAsyncClient(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 createHttpNamespaceAsync(CreateHttpNamespaceRequest request) {
return createHttpNamespaceAsync(request, null);
}
@Override
public java.util.concurrent.Future createHttpNamespaceAsync(final CreateHttpNamespaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateHttpNamespaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateHttpNamespaceResult call() throws Exception {
CreateHttpNamespaceResult result = null;
try {
result = executeCreateHttpNamespace(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 createPrivateDnsNamespaceAsync(CreatePrivateDnsNamespaceRequest request) {
return createPrivateDnsNamespaceAsync(request, null);
}
@Override
public java.util.concurrent.Future createPrivateDnsNamespaceAsync(final CreatePrivateDnsNamespaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreatePrivateDnsNamespaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreatePrivateDnsNamespaceResult call() throws Exception {
CreatePrivateDnsNamespaceResult result = null;
try {
result = executeCreatePrivateDnsNamespace(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 createPublicDnsNamespaceAsync(CreatePublicDnsNamespaceRequest request) {
return createPublicDnsNamespaceAsync(request, null);
}
@Override
public java.util.concurrent.Future createPublicDnsNamespaceAsync(final CreatePublicDnsNamespaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreatePublicDnsNamespaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreatePublicDnsNamespaceResult call() throws Exception {
CreatePublicDnsNamespaceResult result = null;
try {
result = executeCreatePublicDnsNamespace(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 createServiceAsync(CreateServiceRequest request) {
return createServiceAsync(request, null);
}
@Override
public java.util.concurrent.Future createServiceAsync(final CreateServiceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CreateServiceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CreateServiceResult call() throws Exception {
CreateServiceResult result = null;
try {
result = executeCreateService(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 deleteNamespaceAsync(DeleteNamespaceRequest request) {
return deleteNamespaceAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteNamespaceAsync(final DeleteNamespaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteNamespaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteNamespaceResult call() throws Exception {
DeleteNamespaceResult result = null;
try {
result = executeDeleteNamespace(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 deleteServiceAsync(DeleteServiceRequest request) {
return deleteServiceAsync(request, null);
}
@Override
public java.util.concurrent.Future deleteServiceAsync(final DeleteServiceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeleteServiceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeleteServiceResult call() throws Exception {
DeleteServiceResult result = null;
try {
result = executeDeleteService(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 deregisterInstanceAsync(DeregisterInstanceRequest request) {
return deregisterInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future deregisterInstanceAsync(final DeregisterInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DeregisterInstanceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DeregisterInstanceResult call() throws Exception {
DeregisterInstanceResult result = null;
try {
result = executeDeregisterInstance(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 discoverInstancesAsync(DiscoverInstancesRequest request) {
return discoverInstancesAsync(request, null);
}
@Override
public java.util.concurrent.Future discoverInstancesAsync(final DiscoverInstancesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DiscoverInstancesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DiscoverInstancesResult call() throws Exception {
DiscoverInstancesResult result = null;
try {
result = executeDiscoverInstances(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 discoverInstancesRevisionAsync(DiscoverInstancesRevisionRequest request) {
return discoverInstancesRevisionAsync(request, null);
}
@Override
public java.util.concurrent.Future discoverInstancesRevisionAsync(final DiscoverInstancesRevisionRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DiscoverInstancesRevisionRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DiscoverInstancesRevisionResult call() throws Exception {
DiscoverInstancesRevisionResult result = null;
try {
result = executeDiscoverInstancesRevision(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 getInstanceAsync(GetInstanceRequest request) {
return getInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future getInstanceAsync(final GetInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetInstanceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetInstanceResult call() throws Exception {
GetInstanceResult result = null;
try {
result = executeGetInstance(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 getInstancesHealthStatusAsync(GetInstancesHealthStatusRequest request) {
return getInstancesHealthStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future getInstancesHealthStatusAsync(final GetInstancesHealthStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetInstancesHealthStatusRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetInstancesHealthStatusResult call() throws Exception {
GetInstancesHealthStatusResult result = null;
try {
result = executeGetInstancesHealthStatus(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 getNamespaceAsync(GetNamespaceRequest request) {
return getNamespaceAsync(request, null);
}
@Override
public java.util.concurrent.Future getNamespaceAsync(final GetNamespaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetNamespaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetNamespaceResult call() throws Exception {
GetNamespaceResult result = null;
try {
result = executeGetNamespace(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 getOperationAsync(GetOperationRequest request) {
return getOperationAsync(request, null);
}
@Override
public java.util.concurrent.Future getOperationAsync(final GetOperationRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetOperationRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetOperationResult call() throws Exception {
GetOperationResult result = null;
try {
result = executeGetOperation(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 getServiceAsync(GetServiceRequest request) {
return getServiceAsync(request, null);
}
@Override
public java.util.concurrent.Future getServiceAsync(final GetServiceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final GetServiceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public GetServiceResult call() throws Exception {
GetServiceResult result = null;
try {
result = executeGetService(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 listInstancesAsync(ListInstancesRequest request) {
return listInstancesAsync(request, null);
}
@Override
public java.util.concurrent.Future listInstancesAsync(final ListInstancesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListInstancesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListInstancesResult call() throws Exception {
ListInstancesResult result = null;
try {
result = executeListInstances(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 listNamespacesAsync(ListNamespacesRequest request) {
return listNamespacesAsync(request, null);
}
@Override
public java.util.concurrent.Future listNamespacesAsync(final ListNamespacesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListNamespacesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListNamespacesResult call() throws Exception {
ListNamespacesResult result = null;
try {
result = executeListNamespaces(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 listOperationsAsync(ListOperationsRequest request) {
return listOperationsAsync(request, null);
}
@Override
public java.util.concurrent.Future listOperationsAsync(final ListOperationsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListOperationsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListOperationsResult call() throws Exception {
ListOperationsResult result = null;
try {
result = executeListOperations(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 listServicesAsync(ListServicesRequest request) {
return listServicesAsync(request, null);
}
@Override
public java.util.concurrent.Future listServicesAsync(final ListServicesRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListServicesRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListServicesResult call() throws Exception {
ListServicesResult result = null;
try {
result = executeListServices(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 registerInstanceAsync(RegisterInstanceRequest request) {
return registerInstanceAsync(request, null);
}
@Override
public java.util.concurrent.Future registerInstanceAsync(final RegisterInstanceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RegisterInstanceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RegisterInstanceResult call() throws Exception {
RegisterInstanceResult result = null;
try {
result = executeRegisterInstance(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 updateHttpNamespaceAsync(UpdateHttpNamespaceRequest request) {
return updateHttpNamespaceAsync(request, null);
}
@Override
public java.util.concurrent.Future updateHttpNamespaceAsync(final UpdateHttpNamespaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateHttpNamespaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateHttpNamespaceResult call() throws Exception {
UpdateHttpNamespaceResult result = null;
try {
result = executeUpdateHttpNamespace(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 updateInstanceCustomHealthStatusAsync(
UpdateInstanceCustomHealthStatusRequest request) {
return updateInstanceCustomHealthStatusAsync(request, null);
}
@Override
public java.util.concurrent.Future updateInstanceCustomHealthStatusAsync(
final UpdateInstanceCustomHealthStatusRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateInstanceCustomHealthStatusRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateInstanceCustomHealthStatusResult call() throws Exception {
UpdateInstanceCustomHealthStatusResult result = null;
try {
result = executeUpdateInstanceCustomHealthStatus(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 updatePrivateDnsNamespaceAsync(UpdatePrivateDnsNamespaceRequest request) {
return updatePrivateDnsNamespaceAsync(request, null);
}
@Override
public java.util.concurrent.Future updatePrivateDnsNamespaceAsync(final UpdatePrivateDnsNamespaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdatePrivateDnsNamespaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdatePrivateDnsNamespaceResult call() throws Exception {
UpdatePrivateDnsNamespaceResult result = null;
try {
result = executeUpdatePrivateDnsNamespace(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 updatePublicDnsNamespaceAsync(UpdatePublicDnsNamespaceRequest request) {
return updatePublicDnsNamespaceAsync(request, null);
}
@Override
public java.util.concurrent.Future updatePublicDnsNamespaceAsync(final UpdatePublicDnsNamespaceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdatePublicDnsNamespaceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdatePublicDnsNamespaceResult call() throws Exception {
UpdatePublicDnsNamespaceResult result = null;
try {
result = executeUpdatePublicDnsNamespace(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 updateServiceAsync(UpdateServiceRequest request) {
return updateServiceAsync(request, null);
}
@Override
public java.util.concurrent.Future updateServiceAsync(final UpdateServiceRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final UpdateServiceRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public UpdateServiceResult call() throws Exception {
UpdateServiceResult result = null;
try {
result = executeUpdateService(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();
}
}