com.amazonaws.services.iotsecuretunneling.AWSIoTSecureTunnelingAsyncClient Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aws-java-sdk-iotsecuretunneling Show documentation
Show all versions of aws-java-sdk-iotsecuretunneling Show documentation
The AWS Java SDK for AWS IoT Secure Tunneling module holds the client classes that are used for communicating with AWS IoT Secure Tunneling Service
The newest version!
/*
* 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.iotsecuretunneling;
import javax.annotation.Generated;
import com.amazonaws.services.iotsecuretunneling.model.*;
import com.amazonaws.client.AwsAsyncClientParams;
import com.amazonaws.annotation.ThreadSafe;
import java.util.concurrent.ExecutorService;
/**
* Client for accessing AWS IoT Secure Tunneling 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.
*
* IoT Secure Tunneling
*
* IoT Secure Tunneling creates remote connections to devices deployed in the field.
*
*
* For more information about how IoT Secure Tunneling works, see IoT Secure Tunneling.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AWSIoTSecureTunnelingAsyncClient extends AWSIoTSecureTunnelingClient implements AWSIoTSecureTunnelingAsync {
private static final int DEFAULT_THREAD_POOL_SIZE = 50;
private final java.util.concurrent.ExecutorService executorService;
public static AWSIoTSecureTunnelingAsyncClientBuilder asyncBuilder() {
return AWSIoTSecureTunnelingAsyncClientBuilder.standard();
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS IoT Secure Tunneling using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
*/
AWSIoTSecureTunnelingAsyncClient(AwsAsyncClientParams asyncClientParams) {
this(asyncClientParams, false);
}
/**
* Constructs a new asynchronous client to invoke service methods on AWS IoT Secure Tunneling using the specified
* parameters.
*
* @param asyncClientParams
* Object providing client parameters.
* @param endpointDiscoveryEnabled
* true will enable endpoint discovery if the service supports it.
*/
AWSIoTSecureTunnelingAsyncClient(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 closeTunnelAsync(CloseTunnelRequest request) {
return closeTunnelAsync(request, null);
}
@Override
public java.util.concurrent.Future closeTunnelAsync(final CloseTunnelRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final CloseTunnelRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public CloseTunnelResult call() throws Exception {
CloseTunnelResult result = null;
try {
result = executeCloseTunnel(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 describeTunnelAsync(DescribeTunnelRequest request) {
return describeTunnelAsync(request, null);
}
@Override
public java.util.concurrent.Future describeTunnelAsync(final DescribeTunnelRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final DescribeTunnelRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public DescribeTunnelResult call() throws Exception {
DescribeTunnelResult result = null;
try {
result = executeDescribeTunnel(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 listTunnelsAsync(ListTunnelsRequest request) {
return listTunnelsAsync(request, null);
}
@Override
public java.util.concurrent.Future listTunnelsAsync(final ListTunnelsRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final ListTunnelsRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public ListTunnelsResult call() throws Exception {
ListTunnelsResult result = null;
try {
result = executeListTunnels(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 openTunnelAsync(OpenTunnelRequest request) {
return openTunnelAsync(request, null);
}
@Override
public java.util.concurrent.Future openTunnelAsync(final OpenTunnelRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final OpenTunnelRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public OpenTunnelResult call() throws Exception {
OpenTunnelResult result = null;
try {
result = executeOpenTunnel(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 rotateTunnelAccessTokenAsync(RotateTunnelAccessTokenRequest request) {
return rotateTunnelAccessTokenAsync(request, null);
}
@Override
public java.util.concurrent.Future rotateTunnelAccessTokenAsync(final RotateTunnelAccessTokenRequest request,
final com.amazonaws.handlers.AsyncHandler asyncHandler) {
final RotateTunnelAccessTokenRequest finalRequest = beforeClientExecution(request);
return executorService.submit(new java.util.concurrent.Callable() {
@Override
public RotateTunnelAccessTokenResult call() throws Exception {
RotateTunnelAccessTokenResult result = null;
try {
result = executeRotateTunnelAccessToken(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;
}
});
}
/**
* 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();
}
}