software.amazon.awssdk.services.kinesisanalytics.DefaultKinesisAnalyticsAsyncClient Maven / Gradle / Ivy
/*
* Copyright 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 software.amazon.awssdk.services.kinesisanalytics;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import java.util.function.Function;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.awscore.client.handler.AwsAsyncClientHandler;
import software.amazon.awssdk.awscore.exception.AwsServiceException;
import software.amazon.awssdk.awscore.internal.AwsProtocolMetadata;
import software.amazon.awssdk.awscore.internal.AwsServiceProtocol;
import software.amazon.awssdk.awscore.retry.AwsRetryStrategy;
import software.amazon.awssdk.core.RequestOverrideConfiguration;
import software.amazon.awssdk.core.SdkPlugin;
import software.amazon.awssdk.core.SdkRequest;
import software.amazon.awssdk.core.client.config.ClientOverrideConfiguration;
import software.amazon.awssdk.core.client.config.SdkClientConfiguration;
import software.amazon.awssdk.core.client.config.SdkClientOption;
import software.amazon.awssdk.core.client.handler.AsyncClientHandler;
import software.amazon.awssdk.core.client.handler.ClientExecutionParams;
import software.amazon.awssdk.core.http.HttpResponseHandler;
import software.amazon.awssdk.core.metrics.CoreMetric;
import software.amazon.awssdk.core.retry.RetryMode;
import software.amazon.awssdk.metrics.MetricCollector;
import software.amazon.awssdk.metrics.MetricPublisher;
import software.amazon.awssdk.metrics.NoOpMetricCollector;
import software.amazon.awssdk.protocols.core.ExceptionMetadata;
import software.amazon.awssdk.protocols.json.AwsJsonProtocol;
import software.amazon.awssdk.protocols.json.AwsJsonProtocolFactory;
import software.amazon.awssdk.protocols.json.BaseAwsJsonProtocolFactory;
import software.amazon.awssdk.protocols.json.JsonOperationMetadata;
import software.amazon.awssdk.retries.api.RetryStrategy;
import software.amazon.awssdk.services.kinesisanalytics.internal.KinesisAnalyticsServiceClientConfigurationBuilder;
import software.amazon.awssdk.services.kinesisanalytics.model.AddApplicationCloudWatchLoggingOptionRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.AddApplicationCloudWatchLoggingOptionResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.AddApplicationInputProcessingConfigurationRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.AddApplicationInputProcessingConfigurationResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.AddApplicationInputRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.AddApplicationInputResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.AddApplicationOutputRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.AddApplicationOutputResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.AddApplicationReferenceDataSourceRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.AddApplicationReferenceDataSourceResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.CodeValidationException;
import software.amazon.awssdk.services.kinesisanalytics.model.ConcurrentModificationException;
import software.amazon.awssdk.services.kinesisanalytics.model.CreateApplicationRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.CreateApplicationResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.DeleteApplicationCloudWatchLoggingOptionRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.DeleteApplicationCloudWatchLoggingOptionResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.DeleteApplicationInputProcessingConfigurationRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.DeleteApplicationInputProcessingConfigurationResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.DeleteApplicationOutputRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.DeleteApplicationOutputResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.DeleteApplicationReferenceDataSourceRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.DeleteApplicationReferenceDataSourceResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.DeleteApplicationRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.DeleteApplicationResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.DescribeApplicationRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.DescribeApplicationResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.DiscoverInputSchemaRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.DiscoverInputSchemaResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.InvalidApplicationConfigurationException;
import software.amazon.awssdk.services.kinesisanalytics.model.InvalidArgumentException;
import software.amazon.awssdk.services.kinesisanalytics.model.KinesisAnalyticsException;
import software.amazon.awssdk.services.kinesisanalytics.model.LimitExceededException;
import software.amazon.awssdk.services.kinesisanalytics.model.ListApplicationsRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.ListApplicationsResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.ListTagsForResourceRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.ListTagsForResourceResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.ResourceInUseException;
import software.amazon.awssdk.services.kinesisanalytics.model.ResourceNotFoundException;
import software.amazon.awssdk.services.kinesisanalytics.model.ResourceProvisionedThroughputExceededException;
import software.amazon.awssdk.services.kinesisanalytics.model.ServiceUnavailableException;
import software.amazon.awssdk.services.kinesisanalytics.model.StartApplicationRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.StartApplicationResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.StopApplicationRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.StopApplicationResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.TagResourceRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.TagResourceResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.TooManyTagsException;
import software.amazon.awssdk.services.kinesisanalytics.model.UnableToDetectSchemaException;
import software.amazon.awssdk.services.kinesisanalytics.model.UnsupportedOperationException;
import software.amazon.awssdk.services.kinesisanalytics.model.UntagResourceRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.UntagResourceResponse;
import software.amazon.awssdk.services.kinesisanalytics.model.UpdateApplicationRequest;
import software.amazon.awssdk.services.kinesisanalytics.model.UpdateApplicationResponse;
import software.amazon.awssdk.services.kinesisanalytics.transform.AddApplicationCloudWatchLoggingOptionRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.AddApplicationInputProcessingConfigurationRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.AddApplicationInputRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.AddApplicationOutputRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.AddApplicationReferenceDataSourceRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.CreateApplicationRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.DeleteApplicationCloudWatchLoggingOptionRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.DeleteApplicationInputProcessingConfigurationRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.DeleteApplicationOutputRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.DeleteApplicationReferenceDataSourceRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.DeleteApplicationRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.DescribeApplicationRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.DiscoverInputSchemaRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.ListApplicationsRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.ListTagsForResourceRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.StartApplicationRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.StopApplicationRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.TagResourceRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.UntagResourceRequestMarshaller;
import software.amazon.awssdk.services.kinesisanalytics.transform.UpdateApplicationRequestMarshaller;
import software.amazon.awssdk.utils.CompletableFutureUtils;
/**
* Internal implementation of {@link KinesisAnalyticsAsyncClient}.
*
* @see KinesisAnalyticsAsyncClient#builder()
*/
@Generated("software.amazon.awssdk:codegen")
@SdkInternalApi
final class DefaultKinesisAnalyticsAsyncClient implements KinesisAnalyticsAsyncClient {
private static final Logger log = LoggerFactory.getLogger(DefaultKinesisAnalyticsAsyncClient.class);
private static final AwsProtocolMetadata protocolMetadata = AwsProtocolMetadata.builder()
.serviceProtocol(AwsServiceProtocol.AWS_JSON).build();
private final AsyncClientHandler clientHandler;
private final AwsJsonProtocolFactory protocolFactory;
private final SdkClientConfiguration clientConfiguration;
protected DefaultKinesisAnalyticsAsyncClient(SdkClientConfiguration clientConfiguration) {
this.clientHandler = new AwsAsyncClientHandler(clientConfiguration);
this.clientConfiguration = clientConfiguration.toBuilder().option(SdkClientOption.SDK_CLIENT, this).build();
this.protocolFactory = init(AwsJsonProtocolFactory.builder()).build();
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Adds a CloudWatch log stream to monitor application configuration errors. For more information about using
* CloudWatch log streams with Amazon Kinesis Analytics applications, see Working with Amazon
* CloudWatch Logs.
*
*
* @param addApplicationCloudWatchLoggingOptionRequest
* @return A Java Future containing the result of the AddApplicationCloudWatchLoggingOption operation returned by
* the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - InvalidArgumentException Specified input parameter value is invalid.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.AddApplicationCloudWatchLoggingOption
* @see AWS API Documentation
*/
@Override
public CompletableFuture addApplicationCloudWatchLoggingOption(
AddApplicationCloudWatchLoggingOptionRequest addApplicationCloudWatchLoggingOptionRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(addApplicationCloudWatchLoggingOptionRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration,
addApplicationCloudWatchLoggingOptionRequest.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "AddApplicationCloudWatchLoggingOption");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory
.createResponseHandler(operationMetadata, AddApplicationCloudWatchLoggingOptionResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("AddApplicationCloudWatchLoggingOption").withProtocolMetadata(protocolMetadata)
.withMarshaller(new AddApplicationCloudWatchLoggingOptionRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(addApplicationCloudWatchLoggingOptionRequest));
CompletableFuture whenCompleted = executeFuture
.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Adds a streaming source to your Amazon Kinesis application. For conceptual information, see Configuring Application
* Input.
*
*
* You can add a streaming source either when you create an application or you can use this operation to add a
* streaming source after you create an application. For more information, see CreateApplication.
*
*
* Any configuration update, including adding a streaming source using this operation, results in a new version of
* the application. You can use the DescribeApplication operation to find the current application version.
*
*
* This operation requires permissions to perform the kinesisanalytics:AddApplicationInput action.
*
*
* @param addApplicationInputRequest
* @return A Java Future containing the result of the AddApplicationInput operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - InvalidArgumentException Specified input parameter value is invalid.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - CodeValidationException User-provided application code (query) is invalid. This can be a simple
* syntax error.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.AddApplicationInput
* @see AWS API Documentation
*/
@Override
public CompletableFuture addApplicationInput(
AddApplicationInputRequest addApplicationInputRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(addApplicationInputRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, addApplicationInputRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "AddApplicationInput");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, AddApplicationInputResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("AddApplicationInput").withProtocolMetadata(protocolMetadata)
.withMarshaller(new AddApplicationInputRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(addApplicationInputRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Adds an
* InputProcessingConfiguration to an application. An input processor preprocesses records on the input stream
* before the application's SQL code executes. Currently, the only input processor available is AWS Lambda.
*
*
* @param addApplicationInputProcessingConfigurationRequest
* @return A Java Future containing the result of the AddApplicationInputProcessingConfiguration operation returned
* by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - InvalidArgumentException Specified input parameter value is invalid.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.AddApplicationInputProcessingConfiguration
* @see AWS API Documentation
*/
@Override
public CompletableFuture addApplicationInputProcessingConfiguration(
AddApplicationInputProcessingConfigurationRequest addApplicationInputProcessingConfigurationRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(
addApplicationInputProcessingConfigurationRequest, this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration,
addApplicationInputProcessingConfigurationRequest.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "AddApplicationInputProcessingConfiguration");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory
.createResponseHandler(operationMetadata, AddApplicationInputProcessingConfigurationResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("AddApplicationInputProcessingConfiguration")
.withProtocolMetadata(protocolMetadata)
.withMarshaller(new AddApplicationInputProcessingConfigurationRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(addApplicationInputProcessingConfigurationRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r,
e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Adds an external destination to your Amazon Kinesis Analytics application.
*
*
* If you want Amazon Kinesis Analytics to deliver data from an in-application stream within your application to an
* external destination (such as an Amazon Kinesis stream, an Amazon Kinesis Firehose delivery stream, or an AWS
* Lambda function), you add the relevant configuration to your application using this operation. You can configure
* one or more outputs for your application. Each output configuration maps an in-application stream and an external
* destination.
*
*
* You can use one of the output configurations to deliver data from your in-application error stream to an external
* destination so that you can analyze the errors. For more information, see Understanding Application
* Output (Destination).
*
*
* Any configuration update, including adding a streaming source using this operation, results in a new version of
* the application. You can use the DescribeApplication operation to find the current application version.
*
*
* For the limits on the number of application inputs and outputs you can configure, see Limits.
*
*
* This operation requires permissions to perform the kinesisanalytics:AddApplicationOutput action.
*
*
* @param addApplicationOutputRequest
* @return A Java Future containing the result of the AddApplicationOutput operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - InvalidArgumentException Specified input parameter value is invalid.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.AddApplicationOutput
* @see AWS API Documentation
*/
@Override
public CompletableFuture addApplicationOutput(
AddApplicationOutputRequest addApplicationOutputRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(addApplicationOutputRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, addApplicationOutputRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "AddApplicationOutput");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, AddApplicationOutputResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("AddApplicationOutput").withProtocolMetadata(protocolMetadata)
.withMarshaller(new AddApplicationOutputRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(addApplicationOutputRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Adds a reference data source to an existing application.
*
*
* Amazon Kinesis Analytics reads reference data (that is, an Amazon S3 object) and creates an in-application table
* within your application. In the request, you provide the source (S3 bucket name and object key name), name of the
* in-application table to create, and the necessary mapping information that describes how data in Amazon S3 object
* maps to columns in the resulting in-application table.
*
*
* For conceptual information, see Configuring Application
* Input. For the limits on data sources you can add to your application, see Limits.
*
*
* This operation requires permissions to perform the kinesisanalytics:AddApplicationOutput action.
*
*
* @param addApplicationReferenceDataSourceRequest
* @return A Java Future containing the result of the AddApplicationReferenceDataSource operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - InvalidArgumentException Specified input parameter value is invalid.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.AddApplicationReferenceDataSource
* @see AWS API Documentation
*/
@Override
public CompletableFuture addApplicationReferenceDataSource(
AddApplicationReferenceDataSourceRequest addApplicationReferenceDataSourceRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(addApplicationReferenceDataSourceRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration,
addApplicationReferenceDataSourceRequest.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "AddApplicationReferenceDataSource");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory
.createResponseHandler(operationMetadata, AddApplicationReferenceDataSourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("AddApplicationReferenceDataSource").withProtocolMetadata(protocolMetadata)
.withMarshaller(new AddApplicationReferenceDataSourceRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(addApplicationReferenceDataSourceRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Creates an Amazon Kinesis Analytics application. You can configure each application with one streaming source as
* input, application code to process the input, and up to three destinations where you want Amazon Kinesis
* Analytics to write the output data from your application. For an overview, see How it Works.
*
*
* In the input configuration, you map the streaming source to an in-application stream, which you can think of as a
* constantly updating table. In the mapping, you must provide a schema for the in-application stream and map each
* data column in the in-application stream to a data element in the streaming source.
*
*
* Your application code is one or more SQL statements that read input data, transform it, and generate output. Your
* application code can create one or more SQL artifacts like SQL streams or pumps.
*
*
* In the output configuration, you can configure the application to write data from in-application streams created
* in your applications to up to three destinations.
*
*
* To read data from your source stream or write data to destination streams, Amazon Kinesis Analytics needs your
* permissions. You grant these permissions by creating IAM roles. This operation requires permissions to perform
* the kinesisanalytics:CreateApplication action.
*
*
* For introductory exercises to create an Amazon Kinesis Analytics application, see Getting Started.
*
*
* @param createApplicationRequest
* TBD
* @return A Java Future containing the result of the CreateApplication operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - CodeValidationException User-provided application code (query) is invalid. This can be a simple
* syntax error.
* - ResourceInUseException Application is not available for this operation.
* - LimitExceededException Exceeded the number of applications allowed.
* - InvalidArgumentException Specified input parameter value is invalid.
* - TooManyTagsException Application created with too many tags, or too many tags added to an
* application. Note that the maximum number of application tags includes system tags. The maximum number of
* user-defined application tags is 50.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.CreateApplication
* @see AWS API Documentation
*/
@Override
public CompletableFuture createApplication(CreateApplicationRequest createApplicationRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(createApplicationRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, createApplicationRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "CreateApplication");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, CreateApplicationResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("CreateApplication").withProtocolMetadata(protocolMetadata)
.withMarshaller(new CreateApplicationRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(createApplicationRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Deletes the specified application. Amazon Kinesis Analytics halts application execution and deletes the
* application, including any application artifacts (such as in-application streams, reference table, and
* application code).
*
*
* This operation requires permissions to perform the kinesisanalytics:DeleteApplication action.
*
*
* @param deleteApplicationRequest
* @return A Java Future containing the result of the DeleteApplication operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.DeleteApplication
* @see AWS API Documentation
*/
@Override
public CompletableFuture deleteApplication(DeleteApplicationRequest deleteApplicationRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(deleteApplicationRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, deleteApplicationRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "DeleteApplication");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeleteApplicationResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteApplication").withProtocolMetadata(protocolMetadata)
.withMarshaller(new DeleteApplicationRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(deleteApplicationRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Deletes a CloudWatch log stream from an application. For more information about using CloudWatch log streams with
* Amazon Kinesis Analytics applications, see Working with Amazon
* CloudWatch Logs.
*
*
* @param deleteApplicationCloudWatchLoggingOptionRequest
* @return A Java Future containing the result of the DeleteApplicationCloudWatchLoggingOption operation returned by
* the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - InvalidArgumentException Specified input parameter value is invalid.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.DeleteApplicationCloudWatchLoggingOption
* @see AWS API Documentation
*/
@Override
public CompletableFuture deleteApplicationCloudWatchLoggingOption(
DeleteApplicationCloudWatchLoggingOptionRequest deleteApplicationCloudWatchLoggingOptionRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(
deleteApplicationCloudWatchLoggingOptionRequest, this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration,
deleteApplicationCloudWatchLoggingOptionRequest.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "DeleteApplicationCloudWatchLoggingOption");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory
.createResponseHandler(operationMetadata, DeleteApplicationCloudWatchLoggingOptionResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteApplicationCloudWatchLoggingOption").withProtocolMetadata(protocolMetadata)
.withMarshaller(new DeleteApplicationCloudWatchLoggingOptionRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(deleteApplicationCloudWatchLoggingOptionRequest));
CompletableFuture whenCompleted = executeFuture
.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Deletes an InputProcessingConfiguration from an input.
*
*
* @param deleteApplicationInputProcessingConfigurationRequest
* @return A Java Future containing the result of the DeleteApplicationInputProcessingConfiguration operation
* returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - InvalidArgumentException Specified input parameter value is invalid.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.DeleteApplicationInputProcessingConfiguration
* @see AWS API Documentation
*/
@Override
public CompletableFuture deleteApplicationInputProcessingConfiguration(
DeleteApplicationInputProcessingConfigurationRequest deleteApplicationInputProcessingConfigurationRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(
deleteApplicationInputProcessingConfigurationRequest, this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration,
deleteApplicationInputProcessingConfigurationRequest.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "DeleteApplicationInputProcessingConfiguration");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory
.createResponseHandler(operationMetadata, DeleteApplicationInputProcessingConfigurationResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteApplicationInputProcessingConfiguration")
.withProtocolMetadata(protocolMetadata)
.withMarshaller(new DeleteApplicationInputProcessingConfigurationRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(deleteApplicationInputProcessingConfigurationRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((
r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Deletes output destination configuration from your application configuration. Amazon Kinesis Analytics will no
* longer write data from the corresponding in-application stream to the external output destination.
*
*
* This operation requires permissions to perform the kinesisanalytics:DeleteApplicationOutput action.
*
*
* @param deleteApplicationOutputRequest
* @return A Java Future containing the result of the DeleteApplicationOutput operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - InvalidArgumentException Specified input parameter value is invalid.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.DeleteApplicationOutput
* @see AWS API Documentation
*/
@Override
public CompletableFuture deleteApplicationOutput(
DeleteApplicationOutputRequest deleteApplicationOutputRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(deleteApplicationOutputRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, deleteApplicationOutputRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "DeleteApplicationOutput");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DeleteApplicationOutputResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteApplicationOutput").withProtocolMetadata(protocolMetadata)
.withMarshaller(new DeleteApplicationOutputRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(deleteApplicationOutputRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Deletes a reference data source configuration from the specified application configuration.
*
*
* If the application is running, Amazon Kinesis Analytics immediately removes the in-application table that you
* created using the AddApplicationReferenceDataSource operation.
*
*
* This operation requires permissions to perform the
* kinesisanalytics.DeleteApplicationReferenceDataSource action.
*
*
* @param deleteApplicationReferenceDataSourceRequest
* @return A Java Future containing the result of the DeleteApplicationReferenceDataSource operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - InvalidArgumentException Specified input parameter value is invalid.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.DeleteApplicationReferenceDataSource
* @see AWS API Documentation
*/
@Override
public CompletableFuture deleteApplicationReferenceDataSource(
DeleteApplicationReferenceDataSourceRequest deleteApplicationReferenceDataSourceRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(deleteApplicationReferenceDataSourceRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration,
deleteApplicationReferenceDataSourceRequest.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "DeleteApplicationReferenceDataSource");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory
.createResponseHandler(operationMetadata, DeleteApplicationReferenceDataSourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DeleteApplicationReferenceDataSource").withProtocolMetadata(protocolMetadata)
.withMarshaller(new DeleteApplicationReferenceDataSourceRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(deleteApplicationReferenceDataSourceRequest));
CompletableFuture whenCompleted = executeFuture
.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Returns information about a specific Amazon Kinesis Analytics application.
*
*
* If you want to retrieve a list of all applications in your account, use the ListApplications
* operation.
*
*
* This operation requires permissions to perform the kinesisanalytics:DescribeApplication action. You
* can use DescribeApplication to get the current application versionId, which you need to call other
* operations such as Update.
*
*
* @param describeApplicationRequest
* @return A Java Future containing the result of the DescribeApplication operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.DescribeApplication
* @see AWS API Documentation
*/
@Override
public CompletableFuture describeApplication(
DescribeApplicationRequest describeApplicationRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(describeApplicationRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, describeApplicationRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "DescribeApplication");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DescribeApplicationResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DescribeApplication").withProtocolMetadata(protocolMetadata)
.withMarshaller(new DescribeApplicationRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(describeApplicationRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Infers a schema by evaluating sample records on the specified streaming source (Amazon Kinesis stream or Amazon
* Kinesis Firehose delivery stream) or S3 object. In the response, the operation returns the inferred schema and
* also the sample records that the operation used to infer the schema.
*
*
* You can use the inferred schema when configuring a streaming source for your application. For conceptual
* information, see Configuring Application
* Input. Note that when you create an application using the Amazon Kinesis Analytics console, the console uses
* this operation to infer a schema and show it in the console user interface.
*
*
* This operation requires permissions to perform the kinesisanalytics:DiscoverInputSchema action.
*
*
* @param discoverInputSchemaRequest
* @return A Java Future containing the result of the DiscoverInputSchema operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - InvalidArgumentException Specified input parameter value is invalid.
* - UnableToDetectSchemaException Data format is not valid. Amazon Kinesis Analytics is not able to
* detect schema for the given streaming source.
* - ResourceProvisionedThroughputExceededException Discovery failed to get a record from the streaming
* source because of the Amazon Kinesis Streams ProvisionedThroughputExceededException. For more
* information, see GetRecords in the
* Amazon Kinesis Streams API Reference.
* - ServiceUnavailableException The service is unavailable. Back off and retry the operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.DiscoverInputSchema
* @see AWS API Documentation
*/
@Override
public CompletableFuture discoverInputSchema(
DiscoverInputSchemaRequest discoverInputSchemaRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(discoverInputSchemaRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, discoverInputSchemaRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "DiscoverInputSchema");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, DiscoverInputSchemaResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("DiscoverInputSchema").withProtocolMetadata(protocolMetadata)
.withMarshaller(new DiscoverInputSchemaRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(discoverInputSchemaRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Returns a list of Amazon Kinesis Analytics applications in your account. For each application, the response
* includes the application name, Amazon Resource Name (ARN), and status. If the response returns the
* HasMoreApplications value as true, you can send another request by adding the
* ExclusiveStartApplicationName in the request body, and set the value of this to the last application
* name from the previous response.
*
*
* If you want detailed information about a specific application, use DescribeApplication.
*
*
* This operation requires permissions to perform the kinesisanalytics:ListApplications action.
*
*
* @param listApplicationsRequest
* @return A Java Future containing the result of the ListApplications operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.ListApplications
* @see AWS API Documentation
*/
@Override
public CompletableFuture listApplications(ListApplicationsRequest listApplicationsRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(listApplicationsRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, listApplicationsRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "ListApplications");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, ListApplicationsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("ListApplications").withProtocolMetadata(protocolMetadata)
.withMarshaller(new ListApplicationsRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(listApplicationsRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Retrieves the list of key-value tags assigned to the application. For more information, see Using Tagging.
*
*
* @param listTagsForResourceRequest
* @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - InvalidArgumentException Specified input parameter value is invalid.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.ListTagsForResource
* @see AWS API Documentation
*/
@Override
public CompletableFuture listTagsForResource(
ListTagsForResourceRequest listTagsForResourceRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(listTagsForResourceRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, listTagsForResourceRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "ListTagsForResource");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, ListTagsForResourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("ListTagsForResource").withProtocolMetadata(protocolMetadata)
.withMarshaller(new ListTagsForResourceRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(listTagsForResourceRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Starts the specified Amazon Kinesis Analytics application. After creating an application, you must exclusively
* call this operation to start your application.
*
*
* After the application starts, it begins consuming the input data, processes it, and writes the output to the
* configured destination.
*
*
* The application status must be READY for you to start an application. You can get the application
* status in the console or using the DescribeApplication operation.
*
*
* After you start the application, you can stop the application from processing the input by calling the StopApplication
* operation.
*
*
* This operation requires permissions to perform the kinesisanalytics:StartApplication action.
*
*
* @param startApplicationRequest
* @return A Java Future containing the result of the StartApplication operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - InvalidArgumentException Specified input parameter value is invalid.
* - InvalidApplicationConfigurationException User-provided application configuration is not valid.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.StartApplication
* @see AWS API Documentation
*/
@Override
public CompletableFuture startApplication(StartApplicationRequest startApplicationRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(startApplicationRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, startApplicationRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "StartApplication");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, StartApplicationResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("StartApplication").withProtocolMetadata(protocolMetadata)
.withMarshaller(new StartApplicationRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(startApplicationRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Stops the application from processing input data. You can stop an application only if it is in the running state.
* You can use the DescribeApplication
* operation to find the application state. After the application is stopped, Amazon Kinesis Analytics stops
* reading data from the input, the application stops processing data, and there is no output written to the
* destination.
*
*
* This operation requires permissions to perform the kinesisanalytics:StopApplication action.
*
*
* @param stopApplicationRequest
* @return A Java Future containing the result of the StopApplication operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.StopApplication
* @see AWS API Documentation
*/
@Override
public CompletableFuture stopApplication(StopApplicationRequest stopApplicationRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(stopApplicationRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, stopApplicationRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "StopApplication");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, StopApplicationResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("StopApplication").withProtocolMetadata(protocolMetadata)
.withMarshaller(new StopApplicationRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(stopApplicationRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Adds one or more key-value tags to a Kinesis Analytics application. Note that the maximum number of application
* tags includes system tags. The maximum number of user-defined application tags is 50. For more information, see
* Using Tagging.
*
*
* @param tagResourceRequest
* @return A Java Future containing the result of the TagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - TooManyTagsException Application created with too many tags, or too many tags added to an
* application. Note that the maximum number of application tags includes system tags. The maximum number of
* user-defined application tags is 50.
* - InvalidArgumentException Specified input parameter value is invalid.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.TagResource
* @see AWS
* API Documentation
*/
@Override
public CompletableFuture tagResource(TagResourceRequest tagResourceRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(tagResourceRequest, this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, tagResourceRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "TagResource");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
TagResourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("TagResource").withProtocolMetadata(protocolMetadata)
.withMarshaller(new TagResourceRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(tagResourceRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
* Removes one or more tags from a Kinesis Analytics application. For more information, see Using Tagging.
*
*
* @param untagResourceRequest
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - TooManyTagsException Application created with too many tags, or too many tags added to an
* application. Note that the maximum number of application tags includes system tags. The maximum number of
* user-defined application tags is 50.
* - InvalidArgumentException Specified input parameter value is invalid.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.UntagResource
* @see AWS API Documentation
*/
@Override
public CompletableFuture untagResource(UntagResourceRequest untagResourceRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(untagResourceRequest, this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, untagResourceRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "UntagResource");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
UntagResourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("UntagResource").withProtocolMetadata(protocolMetadata)
.withMarshaller(new UntagResourceRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(untagResourceRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
/**
*
*
* This documentation is for version 1 of the Amazon Kinesis Data Analytics API, which only supports SQL
* applications. Version 2 of the API supports SQL and Java applications. For more information about version 2, see
* Amazon Kinesis Data Analytics API V2 Documentation.
*
*
*
* Updates an existing Amazon Kinesis Analytics application. Using this API, you can update application code, input
* configuration, and output configuration.
*
*
* Note that Amazon Kinesis Analytics updates the CurrentApplicationVersionId each time you update your
* application.
*
*
* This operation requires permission for the kinesisanalytics:UpdateApplication action.
*
*
* @param updateApplicationRequest
* @return A Java Future containing the result of the UpdateApplication operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - CodeValidationException User-provided application code (query) is invalid. This can be a simple
* syntax error.
* - ResourceNotFoundException Specified application can't be found.
* - ResourceInUseException Application is not available for this operation.
* - InvalidArgumentException Specified input parameter value is invalid.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - UnsupportedOperationException The request was rejected because a specified parameter is not supported
* or a specified resource is not valid for this operation.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - KinesisAnalyticsException Base class for all service exceptions. Unknown exceptions will be thrown as
* an instance of this type.
*
* @sample KinesisAnalyticsAsyncClient.UpdateApplication
* @see AWS API Documentation
*/
@Override
public CompletableFuture updateApplication(UpdateApplicationRequest updateApplicationRequest) {
SdkClientConfiguration clientConfiguration = updateSdkClientConfiguration(updateApplicationRequest,
this.clientConfiguration);
List metricPublishers = resolveMetricPublishers(clientConfiguration, updateApplicationRequest
.overrideConfiguration().orElse(null));
MetricCollector apiCallMetricCollector = metricPublishers.isEmpty() ? NoOpMetricCollector.create() : MetricCollector
.create("ApiCall");
try {
apiCallMetricCollector.reportMetric(CoreMetric.SERVICE_ID, "Kinesis Analytics");
apiCallMetricCollector.reportMetric(CoreMetric.OPERATION_NAME, "UpdateApplication");
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, UpdateApplicationResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
CompletableFuture executeFuture = clientHandler
.execute(new ClientExecutionParams()
.withOperationName("UpdateApplication").withProtocolMetadata(protocolMetadata)
.withMarshaller(new UpdateApplicationRequestMarshaller(protocolFactory))
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler)
.withRequestConfiguration(clientConfiguration).withMetricCollector(apiCallMetricCollector)
.withInput(updateApplicationRequest));
CompletableFuture whenCompleted = executeFuture.whenComplete((r, e) -> {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
});
executeFuture = CompletableFutureUtils.forwardExceptionTo(whenCompleted, executeFuture);
return executeFuture;
} catch (Throwable t) {
metricPublishers.forEach(p -> p.publish(apiCallMetricCollector.collect()));
return CompletableFutureUtils.failedFuture(t);
}
}
@Override
public final KinesisAnalyticsServiceClientConfiguration serviceClientConfiguration() {
return new KinesisAnalyticsServiceClientConfigurationBuilder(this.clientConfiguration.toBuilder()).build();
}
@Override
public final String serviceName() {
return SERVICE_NAME;
}
private > T init(T builder) {
return builder
.clientConfiguration(clientConfiguration)
.defaultServiceExceptionSupplier(KinesisAnalyticsException::builder)
.protocol(AwsJsonProtocol.AWS_JSON)
.protocolVersion("1.1")
.registerModeledException(
ExceptionMetadata.builder().errorCode("ConcurrentModificationException")
.exceptionBuilderSupplier(ConcurrentModificationException::builder).httpStatusCode(400).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("UnableToDetectSchemaException")
.exceptionBuilderSupplier(UnableToDetectSchemaException::builder).httpStatusCode(400).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ResourceInUseException")
.exceptionBuilderSupplier(ResourceInUseException::builder).httpStatusCode(400).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ResourceProvisionedThroughputExceededException")
.exceptionBuilderSupplier(ResourceProvisionedThroughputExceededException::builder)
.httpStatusCode(400).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("LimitExceededException")
.exceptionBuilderSupplier(LimitExceededException::builder).httpStatusCode(400).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("InvalidApplicationConfigurationException")
.exceptionBuilderSupplier(InvalidApplicationConfigurationException::builder).httpStatusCode(400)
.build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("TooManyTagsException")
.exceptionBuilderSupplier(TooManyTagsException::builder).httpStatusCode(400).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("CodeValidationException")
.exceptionBuilderSupplier(CodeValidationException::builder).httpStatusCode(400).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("InvalidArgumentException")
.exceptionBuilderSupplier(InvalidArgumentException::builder).httpStatusCode(400).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ResourceNotFoundException")
.exceptionBuilderSupplier(ResourceNotFoundException::builder).httpStatusCode(400).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("UnsupportedOperationException")
.exceptionBuilderSupplier(UnsupportedOperationException::builder).httpStatusCode(400).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ServiceUnavailableException")
.exceptionBuilderSupplier(ServiceUnavailableException::builder).httpStatusCode(500).build());
}
private static List resolveMetricPublishers(SdkClientConfiguration clientConfiguration,
RequestOverrideConfiguration requestOverrideConfiguration) {
List publishers = null;
if (requestOverrideConfiguration != null) {
publishers = requestOverrideConfiguration.metricPublishers();
}
if (publishers == null || publishers.isEmpty()) {
publishers = clientConfiguration.option(SdkClientOption.METRIC_PUBLISHERS);
}
if (publishers == null) {
publishers = Collections.emptyList();
}
return publishers;
}
private void updateRetryStrategyClientConfiguration(SdkClientConfiguration.Builder configuration) {
ClientOverrideConfiguration.Builder builder = configuration.asOverrideConfigurationBuilder();
RetryMode retryMode = builder.retryMode();
if (retryMode != null) {
configuration.option(SdkClientOption.RETRY_STRATEGY, AwsRetryStrategy.forRetryMode(retryMode));
} else {
Consumer> configurator = builder.retryStrategyConfigurator();
if (configurator != null) {
RetryStrategy.Builder defaultBuilder = AwsRetryStrategy.defaultRetryStrategy().toBuilder();
configurator.accept(defaultBuilder);
configuration.option(SdkClientOption.RETRY_STRATEGY, defaultBuilder.build());
} else {
RetryStrategy retryStrategy = builder.retryStrategy();
if (retryStrategy != null) {
configuration.option(SdkClientOption.RETRY_STRATEGY, retryStrategy);
}
}
}
configuration.option(SdkClientOption.CONFIGURED_RETRY_MODE, null);
configuration.option(SdkClientOption.CONFIGURED_RETRY_STRATEGY, null);
configuration.option(SdkClientOption.CONFIGURED_RETRY_CONFIGURATOR, null);
}
private SdkClientConfiguration updateSdkClientConfiguration(SdkRequest request, SdkClientConfiguration clientConfiguration) {
List plugins = request.overrideConfiguration().map(c -> c.plugins()).orElse(Collections.emptyList());
SdkClientConfiguration.Builder configuration = clientConfiguration.toBuilder();
if (plugins.isEmpty()) {
return configuration.build();
}
KinesisAnalyticsServiceClientConfigurationBuilder serviceConfigBuilder = new KinesisAnalyticsServiceClientConfigurationBuilder(
configuration);
for (SdkPlugin plugin : plugins) {
plugin.configureClient(serviceConfigBuilder);
}
updateRetryStrategyClientConfiguration(configuration);
return configuration.build();
}
private HttpResponseHandler createErrorResponseHandler(BaseAwsJsonProtocolFactory protocolFactory,
JsonOperationMetadata operationMetadata) {
return protocolFactory.createErrorResponseHandler(operationMetadata);
}
private HttpResponseHandler createErrorResponseHandler(BaseAwsJsonProtocolFactory protocolFactory,
JsonOperationMetadata operationMetadata, Function> exceptionMetadataMapper) {
return protocolFactory.createErrorResponseHandler(operationMetadata, exceptionMetadataMapper);
}
@Override
public void close() {
clientHandler.close();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy