com.amazonaws.services.lookoutequipment.AmazonLookoutEquipmentClient Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aws-java-sdk-lookoutequipment Show documentation
Show all versions of aws-java-sdk-lookoutequipment Show documentation
The AWS Java SDK for Amazon Lookout for Equipment module holds the client classes that are used for communicating with Amazon Lookout for Equipment Service
/*
* Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package com.amazonaws.services.lookoutequipment;
import org.w3c.dom.*;
import java.net.*;
import java.util.*;
import javax.annotation.Generated;
import org.apache.commons.logging.*;
import com.amazonaws.*;
import com.amazonaws.annotation.SdkInternalApi;
import com.amazonaws.auth.*;
import com.amazonaws.handlers.*;
import com.amazonaws.http.*;
import com.amazonaws.internal.*;
import com.amazonaws.internal.auth.*;
import com.amazonaws.metrics.*;
import com.amazonaws.regions.*;
import com.amazonaws.transform.*;
import com.amazonaws.util.*;
import com.amazonaws.protocol.json.*;
import com.amazonaws.util.AWSRequestMetrics.Field;
import com.amazonaws.annotation.ThreadSafe;
import com.amazonaws.client.AwsSyncClientParams;
import com.amazonaws.client.builder.AdvancedConfig;
import com.amazonaws.services.lookoutequipment.AmazonLookoutEquipmentClientBuilder;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.lookoutequipment.model.*;
import com.amazonaws.services.lookoutequipment.model.transform.*;
/**
* Client for accessing LookoutEquipment. All service calls made using this client are blocking, and will not return
* until the service call completes.
*
*
* Amazon Lookout for Equipment is a machine learning service that uses advanced analytics to identify anomalies in
* machines from sensor data for use in predictive maintenance.
*
*/
@ThreadSafe
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class AmazonLookoutEquipmentClient extends AmazonWebServiceClient implements AmazonLookoutEquipment {
/** Provider for AWS credentials. */
private final AWSCredentialsProvider awsCredentialsProvider;
private static final Log log = LogFactory.getLog(AmazonLookoutEquipment.class);
/** Default signing name for the service. */
private static final String DEFAULT_SIGNING_NAME = "lookoutequipment";
/** Client configuration factory providing ClientConfigurations tailored to this client */
protected static final ClientConfigurationFactory configFactory = new ClientConfigurationFactory();
private final AdvancedConfig advancedConfig;
private static final com.amazonaws.protocol.json.SdkJsonProtocolFactory protocolFactory = new com.amazonaws.protocol.json.SdkJsonProtocolFactory(
new JsonClientMetadata()
.withProtocolVersion("1.0")
.withSupportsCbor(false)
.withSupportsIon(false)
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ThrottlingException").withExceptionUnmarshaller(
com.amazonaws.services.lookoutequipment.model.transform.ThrottlingExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ServiceQuotaExceededException").withExceptionUnmarshaller(
com.amazonaws.services.lookoutequipment.model.transform.ServiceQuotaExceededExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("InternalServerException").withExceptionUnmarshaller(
com.amazonaws.services.lookoutequipment.model.transform.InternalServerExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("AccessDeniedException").withExceptionUnmarshaller(
com.amazonaws.services.lookoutequipment.model.transform.AccessDeniedExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ConflictException").withExceptionUnmarshaller(
com.amazonaws.services.lookoutequipment.model.transform.ConflictExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ResourceNotFoundException").withExceptionUnmarshaller(
com.amazonaws.services.lookoutequipment.model.transform.ResourceNotFoundExceptionUnmarshaller.getInstance()))
.addErrorMetadata(
new JsonErrorShapeMetadata().withErrorCode("ValidationException").withExceptionUnmarshaller(
com.amazonaws.services.lookoutequipment.model.transform.ValidationExceptionUnmarshaller.getInstance()))
.withBaseServiceExceptionClass(com.amazonaws.services.lookoutequipment.model.AmazonLookoutEquipmentException.class));
public static AmazonLookoutEquipmentClientBuilder builder() {
return AmazonLookoutEquipmentClientBuilder.standard();
}
/**
* Constructs a new client to invoke service methods on LookoutEquipment using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonLookoutEquipmentClient(AwsSyncClientParams clientParams) {
this(clientParams, false);
}
/**
* Constructs a new client to invoke service methods on LookoutEquipment using the specified parameters.
*
*
* All service calls made using this new client object are blocking, and will not return until the service call
* completes.
*
* @param clientParams
* Object providing client parameters.
*/
AmazonLookoutEquipmentClient(AwsSyncClientParams clientParams, boolean endpointDiscoveryEnabled) {
super(clientParams);
this.awsCredentialsProvider = clientParams.getCredentialsProvider();
this.advancedConfig = clientParams.getAdvancedConfig();
init();
}
private void init() {
setServiceNameIntern(DEFAULT_SIGNING_NAME);
setEndpointPrefix(ENDPOINT_PREFIX);
// calling this.setEndPoint(...) will also modify the signer accordingly
setEndpoint("lookoutequipment.us-east-1.amazonaws.com");
HandlerChainFactory chainFactory = new HandlerChainFactory();
requestHandler2s.addAll(chainFactory.newRequestHandlerChain("/com/amazonaws/services/lookoutequipment/request.handlers"));
requestHandler2s.addAll(chainFactory.newRequestHandler2Chain("/com/amazonaws/services/lookoutequipment/request.handler2s"));
requestHandler2s.addAll(chainFactory.getGlobalHandlers());
}
/**
*
* Creates a container for a collection of data being ingested for analysis. The dataset contains the metadata
* describing where the data is and what the data actually looks like. For example, it contains the location of the
* data source, the data schema, and other information. A dataset also contains any tags associated with the
* ingested data.
*
*
* @param createDatasetRequest
* @return Result of the CreateDataset operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ServiceQuotaExceededException
* Resource limitations have been exceeded.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.CreateDataset
* @see AWS
* API Documentation
*/
@Override
public CreateDatasetResult createDataset(CreateDatasetRequest request) {
request = beforeClientExecution(request);
return executeCreateDataset(request);
}
@SdkInternalApi
final CreateDatasetResult executeCreateDataset(CreateDatasetRequest createDatasetRequest) {
ExecutionContext executionContext = createExecutionContext(createDatasetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateDatasetRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createDatasetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateDataset");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateDatasetResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a scheduled inference. Scheduling an inference is setting up a continuous real-time inference plan to
* analyze new measurement data. When setting up the schedule, you provide an S3 bucket location for the input data,
* assign it a delimiter between separate entries in the data, set an offset delay if desired, and set the frequency
* of inferencing. You must also provide an S3 bucket location for the output data.
*
*
* @param createInferenceSchedulerRequest
* @return Result of the CreateInferenceScheduler operation returned by the service.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ServiceQuotaExceededException
* Resource limitations have been exceeded.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.CreateInferenceScheduler
* @see AWS API Documentation
*/
@Override
public CreateInferenceSchedulerResult createInferenceScheduler(CreateInferenceSchedulerRequest request) {
request = beforeClientExecution(request);
return executeCreateInferenceScheduler(request);
}
@SdkInternalApi
final CreateInferenceSchedulerResult executeCreateInferenceScheduler(CreateInferenceSchedulerRequest createInferenceSchedulerRequest) {
ExecutionContext executionContext = createExecutionContext(createInferenceSchedulerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateInferenceSchedulerRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createInferenceSchedulerRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateInferenceScheduler");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateInferenceSchedulerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a label for an event.
*
*
* @param createLabelRequest
* @return Result of the CreateLabel operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ServiceQuotaExceededException
* Resource limitations have been exceeded.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.CreateLabel
* @see AWS
* API Documentation
*/
@Override
public CreateLabelResult createLabel(CreateLabelRequest request) {
request = beforeClientExecution(request);
return executeCreateLabel(request);
}
@SdkInternalApi
final CreateLabelResult executeCreateLabel(CreateLabelRequest createLabelRequest) {
ExecutionContext executionContext = createExecutionContext(createLabelRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateLabelRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createLabelRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateLabel");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateLabelResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a group of labels.
*
*
* @param createLabelGroupRequest
* @return Result of the CreateLabelGroup operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ServiceQuotaExceededException
* Resource limitations have been exceeded.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.CreateLabelGroup
* @see AWS API Documentation
*/
@Override
public CreateLabelGroupResult createLabelGroup(CreateLabelGroupRequest request) {
request = beforeClientExecution(request);
return executeCreateLabelGroup(request);
}
@SdkInternalApi
final CreateLabelGroupResult executeCreateLabelGroup(CreateLabelGroupRequest createLabelGroupRequest) {
ExecutionContext executionContext = createExecutionContext(createLabelGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateLabelGroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createLabelGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateLabelGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateLabelGroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a machine learning model for data inference.
*
*
* A machine-learning (ML) model is a mathematical model that finds patterns in your data. In Amazon Lookout for
* Equipment, the model learns the patterns of normal behavior and detects abnormal behavior that could be potential
* equipment failure (or maintenance events). The models are made by analyzing normal data and abnormalities in
* machine behavior that have already occurred.
*
*
* Your model is trained using a portion of the data from your dataset and uses that data to learn patterns of
* normal behavior and abnormal patterns that lead to equipment failure. Another portion of the data is used to
* evaluate the model's accuracy.
*
*
* @param createModelRequest
* @return Result of the CreateModel operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ServiceQuotaExceededException
* Resource limitations have been exceeded.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @sample AmazonLookoutEquipment.CreateModel
* @see AWS
* API Documentation
*/
@Override
public CreateModelResult createModel(CreateModelRequest request) {
request = beforeClientExecution(request);
return executeCreateModel(request);
}
@SdkInternalApi
final CreateModelResult executeCreateModel(CreateModelRequest createModelRequest) {
ExecutionContext executionContext = createExecutionContext(createModelRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateModelRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(createModelRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateModel");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new CreateModelResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a retraining scheduler on the specified model.
*
*
* @param createRetrainingSchedulerRequest
* @return Result of the CreateRetrainingScheduler operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.CreateRetrainingScheduler
* @see AWS API Documentation
*/
@Override
public CreateRetrainingSchedulerResult createRetrainingScheduler(CreateRetrainingSchedulerRequest request) {
request = beforeClientExecution(request);
return executeCreateRetrainingScheduler(request);
}
@SdkInternalApi
final CreateRetrainingSchedulerResult executeCreateRetrainingScheduler(CreateRetrainingSchedulerRequest createRetrainingSchedulerRequest) {
ExecutionContext executionContext = createExecutionContext(createRetrainingSchedulerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new CreateRetrainingSchedulerRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(createRetrainingSchedulerRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "CreateRetrainingScheduler");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new CreateRetrainingSchedulerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a dataset and associated artifacts. The operation will check to see if any inference scheduler or data
* ingestion job is currently using the dataset, and if there isn't, the dataset, its metadata, and any associated
* data stored in S3 will be deleted. This does not affect any models that used this dataset for training and
* evaluation, but does prevent it from being used in the future.
*
*
* @param deleteDatasetRequest
* @return Result of the DeleteDataset operation returned by the service.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @sample AmazonLookoutEquipment.DeleteDataset
* @see AWS
* API Documentation
*/
@Override
public DeleteDatasetResult deleteDataset(DeleteDatasetRequest request) {
request = beforeClientExecution(request);
return executeDeleteDataset(request);
}
@SdkInternalApi
final DeleteDatasetResult executeDeleteDataset(DeleteDatasetRequest deleteDatasetRequest) {
ExecutionContext executionContext = createExecutionContext(deleteDatasetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteDatasetRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteDatasetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteDataset");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteDatasetResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes an inference scheduler that has been set up. Prior inference results will not be deleted.
*
*
* @param deleteInferenceSchedulerRequest
* @return Result of the DeleteInferenceScheduler operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.DeleteInferenceScheduler
* @see AWS API Documentation
*/
@Override
public DeleteInferenceSchedulerResult deleteInferenceScheduler(DeleteInferenceSchedulerRequest request) {
request = beforeClientExecution(request);
return executeDeleteInferenceScheduler(request);
}
@SdkInternalApi
final DeleteInferenceSchedulerResult executeDeleteInferenceScheduler(DeleteInferenceSchedulerRequest deleteInferenceSchedulerRequest) {
ExecutionContext executionContext = createExecutionContext(deleteInferenceSchedulerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteInferenceSchedulerRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteInferenceSchedulerRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteInferenceScheduler");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteInferenceSchedulerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a label.
*
*
* @param deleteLabelRequest
* @return Result of the DeleteLabel operation returned by the service.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @sample AmazonLookoutEquipment.DeleteLabel
* @see AWS
* API Documentation
*/
@Override
public DeleteLabelResult deleteLabel(DeleteLabelRequest request) {
request = beforeClientExecution(request);
return executeDeleteLabel(request);
}
@SdkInternalApi
final DeleteLabelResult executeDeleteLabel(DeleteLabelRequest deleteLabelRequest) {
ExecutionContext executionContext = createExecutionContext(deleteLabelRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteLabelRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteLabelRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteLabel");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteLabelResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a group of labels.
*
*
* @param deleteLabelGroupRequest
* @return Result of the DeleteLabelGroup operation returned by the service.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @sample AmazonLookoutEquipment.DeleteLabelGroup
* @see AWS API Documentation
*/
@Override
public DeleteLabelGroupResult deleteLabelGroup(DeleteLabelGroupRequest request) {
request = beforeClientExecution(request);
return executeDeleteLabelGroup(request);
}
@SdkInternalApi
final DeleteLabelGroupResult executeDeleteLabelGroup(DeleteLabelGroupRequest deleteLabelGroupRequest) {
ExecutionContext executionContext = createExecutionContext(deleteLabelGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteLabelGroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteLabelGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteLabelGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteLabelGroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a machine learning model currently available for Amazon Lookout for Equipment. This will prevent it from
* being used with an inference scheduler, even one that is already set up.
*
*
* @param deleteModelRequest
* @return Result of the DeleteModel operation returned by the service.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @sample AmazonLookoutEquipment.DeleteModel
* @see AWS
* API Documentation
*/
@Override
public DeleteModelResult deleteModel(DeleteModelRequest request) {
request = beforeClientExecution(request);
return executeDeleteModel(request);
}
@SdkInternalApi
final DeleteModelResult executeDeleteModel(DeleteModelRequest deleteModelRequest) {
ExecutionContext executionContext = createExecutionContext(deleteModelRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteModelRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteModelRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteModel");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteModelResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes the resource policy attached to the resource.
*
*
* @param deleteResourcePolicyRequest
* @return Result of the DeleteResourcePolicy operation returned by the service.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @sample AmazonLookoutEquipment.DeleteResourcePolicy
* @see AWS API Documentation
*/
@Override
public DeleteResourcePolicyResult deleteResourcePolicy(DeleteResourcePolicyRequest request) {
request = beforeClientExecution(request);
return executeDeleteResourcePolicy(request);
}
@SdkInternalApi
final DeleteResourcePolicyResult executeDeleteResourcePolicy(DeleteResourcePolicyRequest deleteResourcePolicyRequest) {
ExecutionContext executionContext = createExecutionContext(deleteResourcePolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteResourcePolicyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(deleteResourcePolicyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteResourcePolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DeleteResourcePolicyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Deletes a retraining scheduler from a model. The retraining scheduler must be in the STOPPED status.
*
*
* @param deleteRetrainingSchedulerRequest
* @return Result of the DeleteRetrainingScheduler operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.DeleteRetrainingScheduler
* @see AWS API Documentation
*/
@Override
public DeleteRetrainingSchedulerResult deleteRetrainingScheduler(DeleteRetrainingSchedulerRequest request) {
request = beforeClientExecution(request);
return executeDeleteRetrainingScheduler(request);
}
@SdkInternalApi
final DeleteRetrainingSchedulerResult executeDeleteRetrainingScheduler(DeleteRetrainingSchedulerRequest deleteRetrainingSchedulerRequest) {
ExecutionContext executionContext = createExecutionContext(deleteRetrainingSchedulerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DeleteRetrainingSchedulerRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(deleteRetrainingSchedulerRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DeleteRetrainingScheduler");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DeleteRetrainingSchedulerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides information on a specific data ingestion job such as creation time, dataset ARN, and status.
*
*
* @param describeDataIngestionJobRequest
* @return Result of the DescribeDataIngestionJob operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.DescribeDataIngestionJob
* @see AWS API Documentation
*/
@Override
public DescribeDataIngestionJobResult describeDataIngestionJob(DescribeDataIngestionJobRequest request) {
request = beforeClientExecution(request);
return executeDescribeDataIngestionJob(request);
}
@SdkInternalApi
final DescribeDataIngestionJobResult executeDescribeDataIngestionJob(DescribeDataIngestionJobRequest describeDataIngestionJobRequest) {
ExecutionContext executionContext = createExecutionContext(describeDataIngestionJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDataIngestionJobRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeDataIngestionJobRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDataIngestionJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeDataIngestionJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides a JSON description of the data in each time series dataset, including names, column names, and data
* types.
*
*
* @param describeDatasetRequest
* @return Result of the DescribeDataset operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.DescribeDataset
* @see AWS API Documentation
*/
@Override
public DescribeDatasetResult describeDataset(DescribeDatasetRequest request) {
request = beforeClientExecution(request);
return executeDescribeDataset(request);
}
@SdkInternalApi
final DescribeDatasetResult executeDescribeDataset(DescribeDatasetRequest describeDatasetRequest) {
ExecutionContext executionContext = createExecutionContext(describeDatasetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeDatasetRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeDatasetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeDataset");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeDatasetResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Specifies information about the inference scheduler being used, including name, model, status, and associated
* metadata
*
*
* @param describeInferenceSchedulerRequest
* @return Result of the DescribeInferenceScheduler operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.DescribeInferenceScheduler
* @see AWS API Documentation
*/
@Override
public DescribeInferenceSchedulerResult describeInferenceScheduler(DescribeInferenceSchedulerRequest request) {
request = beforeClientExecution(request);
return executeDescribeInferenceScheduler(request);
}
@SdkInternalApi
final DescribeInferenceSchedulerResult executeDescribeInferenceScheduler(DescribeInferenceSchedulerRequest describeInferenceSchedulerRequest) {
ExecutionContext executionContext = createExecutionContext(describeInferenceSchedulerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeInferenceSchedulerRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeInferenceSchedulerRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeInferenceScheduler");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeInferenceSchedulerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns the name of the label.
*
*
* @param describeLabelRequest
* @return Result of the DescribeLabel operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.DescribeLabel
* @see AWS
* API Documentation
*/
@Override
public DescribeLabelResult describeLabel(DescribeLabelRequest request) {
request = beforeClientExecution(request);
return executeDescribeLabel(request);
}
@SdkInternalApi
final DescribeLabelResult executeDescribeLabel(DescribeLabelRequest describeLabelRequest) {
ExecutionContext executionContext = createExecutionContext(describeLabelRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeLabelRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeLabelRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeLabel");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeLabelResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns information about the label group.
*
*
* @param describeLabelGroupRequest
* @return Result of the DescribeLabelGroup operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.DescribeLabelGroup
* @see AWS API Documentation
*/
@Override
public DescribeLabelGroupResult describeLabelGroup(DescribeLabelGroupRequest request) {
request = beforeClientExecution(request);
return executeDescribeLabelGroup(request);
}
@SdkInternalApi
final DescribeLabelGroupResult executeDescribeLabelGroup(DescribeLabelGroupRequest describeLabelGroupRequest) {
ExecutionContext executionContext = createExecutionContext(describeLabelGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeLabelGroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeLabelGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeLabelGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeLabelGroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides a JSON containing the overall information about a specific machine learning model, including model name
* and ARN, dataset, training and evaluation information, status, and so on.
*
*
* @param describeModelRequest
* @return Result of the DescribeModel operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.DescribeModel
* @see AWS
* API Documentation
*/
@Override
public DescribeModelResult describeModel(DescribeModelRequest request) {
request = beforeClientExecution(request);
return executeDescribeModel(request);
}
@SdkInternalApi
final DescribeModelResult executeDescribeModel(DescribeModelRequest describeModelRequest) {
ExecutionContext executionContext = createExecutionContext(describeModelRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeModelRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeModelRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeModel");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeModelResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves information about a specific machine learning model version.
*
*
* @param describeModelVersionRequest
* @return Result of the DescribeModelVersion operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.DescribeModelVersion
* @see AWS API Documentation
*/
@Override
public DescribeModelVersionResult describeModelVersion(DescribeModelVersionRequest request) {
request = beforeClientExecution(request);
return executeDescribeModelVersion(request);
}
@SdkInternalApi
final DescribeModelVersionResult executeDescribeModelVersion(DescribeModelVersionRequest describeModelVersionRequest) {
ExecutionContext executionContext = createExecutionContext(describeModelVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeModelVersionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeModelVersionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeModelVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new DescribeModelVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides the details of a resource policy attached to a resource.
*
*
* @param describeResourcePolicyRequest
* @return Result of the DescribeResourcePolicy operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.DescribeResourcePolicy
* @see AWS API Documentation
*/
@Override
public DescribeResourcePolicyResult describeResourcePolicy(DescribeResourcePolicyRequest request) {
request = beforeClientExecution(request);
return executeDescribeResourcePolicy(request);
}
@SdkInternalApi
final DescribeResourcePolicyResult executeDescribeResourcePolicy(DescribeResourcePolicyRequest describeResourcePolicyRequest) {
ExecutionContext executionContext = createExecutionContext(describeResourcePolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeResourcePolicyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(describeResourcePolicyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeResourcePolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeResourcePolicyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides a description of the retraining scheduler, including information such as the model name and retraining
* parameters.
*
*
* @param describeRetrainingSchedulerRequest
* @return Result of the DescribeRetrainingScheduler operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.DescribeRetrainingScheduler
* @see AWS API Documentation
*/
@Override
public DescribeRetrainingSchedulerResult describeRetrainingScheduler(DescribeRetrainingSchedulerRequest request) {
request = beforeClientExecution(request);
return executeDescribeRetrainingScheduler(request);
}
@SdkInternalApi
final DescribeRetrainingSchedulerResult executeDescribeRetrainingScheduler(DescribeRetrainingSchedulerRequest describeRetrainingSchedulerRequest) {
ExecutionContext executionContext = createExecutionContext(describeRetrainingSchedulerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new DescribeRetrainingSchedulerRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(describeRetrainingSchedulerRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "DescribeRetrainingScheduler");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new DescribeRetrainingSchedulerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Imports a dataset.
*
*
* @param importDatasetRequest
* @return Result of the ImportDataset operation returned by the service.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ServiceQuotaExceededException
* Resource limitations have been exceeded.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ImportDataset
* @see AWS
* API Documentation
*/
@Override
public ImportDatasetResult importDataset(ImportDatasetRequest request) {
request = beforeClientExecution(request);
return executeImportDataset(request);
}
@SdkInternalApi
final ImportDatasetResult executeImportDataset(ImportDatasetRequest importDatasetRequest) {
ExecutionContext executionContext = createExecutionContext(importDatasetRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ImportDatasetRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(importDatasetRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ImportDataset");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ImportDatasetResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Imports a model that has been trained successfully.
*
*
* @param importModelVersionRequest
* @return Result of the ImportModelVersion operation returned by the service.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ServiceQuotaExceededException
* Resource limitations have been exceeded.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ImportModelVersion
* @see AWS API Documentation
*/
@Override
public ImportModelVersionResult importModelVersion(ImportModelVersionRequest request) {
request = beforeClientExecution(request);
return executeImportModelVersion(request);
}
@SdkInternalApi
final ImportModelVersionResult executeImportModelVersion(ImportModelVersionRequest importModelVersionRequest) {
ExecutionContext executionContext = createExecutionContext(importModelVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ImportModelVersionRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(importModelVersionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ImportModelVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ImportModelVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides a list of all data ingestion jobs, including dataset name and ARN, S3 location of the input data,
* status, and so on.
*
*
* @param listDataIngestionJobsRequest
* @return Result of the ListDataIngestionJobs operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ListDataIngestionJobs
* @see AWS API Documentation
*/
@Override
public ListDataIngestionJobsResult listDataIngestionJobs(ListDataIngestionJobsRequest request) {
request = beforeClientExecution(request);
return executeListDataIngestionJobs(request);
}
@SdkInternalApi
final ListDataIngestionJobsResult executeListDataIngestionJobs(ListDataIngestionJobsRequest listDataIngestionJobsRequest) {
ExecutionContext executionContext = createExecutionContext(listDataIngestionJobsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListDataIngestionJobsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listDataIngestionJobsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListDataIngestionJobs");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListDataIngestionJobsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists all datasets currently available in your account, filtering on the dataset name.
*
*
* @param listDatasetsRequest
* @return Result of the ListDatasets operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ListDatasets
* @see AWS
* API Documentation
*/
@Override
public ListDatasetsResult listDatasets(ListDatasetsRequest request) {
request = beforeClientExecution(request);
return executeListDatasets(request);
}
@SdkInternalApi
final ListDatasetsResult executeListDatasets(ListDatasetsRequest listDatasetsRequest) {
ExecutionContext executionContext = createExecutionContext(listDatasetsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListDatasetsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listDatasetsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListDatasets");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListDatasetsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists all inference events that have been found for the specified inference scheduler.
*
*
* @param listInferenceEventsRequest
* @return Result of the ListInferenceEvents operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ListInferenceEvents
* @see AWS API Documentation
*/
@Override
public ListInferenceEventsResult listInferenceEvents(ListInferenceEventsRequest request) {
request = beforeClientExecution(request);
return executeListInferenceEvents(request);
}
@SdkInternalApi
final ListInferenceEventsResult executeListInferenceEvents(ListInferenceEventsRequest listInferenceEventsRequest) {
ExecutionContext executionContext = createExecutionContext(listInferenceEventsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListInferenceEventsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listInferenceEventsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListInferenceEvents");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListInferenceEventsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists all inference executions that have been performed by the specified inference scheduler.
*
*
* @param listInferenceExecutionsRequest
* @return Result of the ListInferenceExecutions operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ListInferenceExecutions
* @see AWS API Documentation
*/
@Override
public ListInferenceExecutionsResult listInferenceExecutions(ListInferenceExecutionsRequest request) {
request = beforeClientExecution(request);
return executeListInferenceExecutions(request);
}
@SdkInternalApi
final ListInferenceExecutionsResult executeListInferenceExecutions(ListInferenceExecutionsRequest listInferenceExecutionsRequest) {
ExecutionContext executionContext = createExecutionContext(listInferenceExecutionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListInferenceExecutionsRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listInferenceExecutionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListInferenceExecutions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListInferenceExecutionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Retrieves a list of all inference schedulers currently available for your account.
*
*
* @param listInferenceSchedulersRequest
* @return Result of the ListInferenceSchedulers operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ListInferenceSchedulers
* @see AWS API Documentation
*/
@Override
public ListInferenceSchedulersResult listInferenceSchedulers(ListInferenceSchedulersRequest request) {
request = beforeClientExecution(request);
return executeListInferenceSchedulers(request);
}
@SdkInternalApi
final ListInferenceSchedulersResult executeListInferenceSchedulers(ListInferenceSchedulersRequest listInferenceSchedulersRequest) {
ExecutionContext executionContext = createExecutionContext(listInferenceSchedulersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListInferenceSchedulersRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listInferenceSchedulersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListInferenceSchedulers");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListInferenceSchedulersResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Returns a list of the label groups.
*
*
* @param listLabelGroupsRequest
* @return Result of the ListLabelGroups operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ListLabelGroups
* @see AWS API Documentation
*/
@Override
public ListLabelGroupsResult listLabelGroups(ListLabelGroupsRequest request) {
request = beforeClientExecution(request);
return executeListLabelGroups(request);
}
@SdkInternalApi
final ListLabelGroupsResult executeListLabelGroups(ListLabelGroupsRequest listLabelGroupsRequest) {
ExecutionContext executionContext = createExecutionContext(listLabelGroupsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListLabelGroupsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listLabelGroupsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListLabelGroups");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListLabelGroupsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Provides a list of labels.
*
*
* @param listLabelsRequest
* @return Result of the ListLabels operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ListLabels
* @see AWS
* API Documentation
*/
@Override
public ListLabelsResult listLabels(ListLabelsRequest request) {
request = beforeClientExecution(request);
return executeListLabels(request);
}
@SdkInternalApi
final ListLabelsResult executeListLabels(ListLabelsRequest listLabelsRequest) {
ExecutionContext executionContext = createExecutionContext(listLabelsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListLabelsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listLabelsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListLabels");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListLabelsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Generates a list of all model versions for a given model, including the model version, model version ARN, and
* status. To list a subset of versions, use the MaxModelVersion and MinModelVersion
* fields.
*
*
* @param listModelVersionsRequest
* @return Result of the ListModelVersions operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ListModelVersions
* @see AWS API Documentation
*/
@Override
public ListModelVersionsResult listModelVersions(ListModelVersionsRequest request) {
request = beforeClientExecution(request);
return executeListModelVersions(request);
}
@SdkInternalApi
final ListModelVersionsResult executeListModelVersions(ListModelVersionsRequest listModelVersionsRequest) {
ExecutionContext executionContext = createExecutionContext(listModelVersionsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListModelVersionsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listModelVersionsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListModelVersions");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListModelVersionsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Generates a list of all models in the account, including model name and ARN, dataset, and status.
*
*
* @param listModelsRequest
* @return Result of the ListModels operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ListModels
* @see AWS
* API Documentation
*/
@Override
public ListModelsResult listModels(ListModelsRequest request) {
request = beforeClientExecution(request);
return executeListModels(request);
}
@SdkInternalApi
final ListModelsResult executeListModels(ListModelsRequest listModelsRequest) {
ExecutionContext executionContext = createExecutionContext(listModelsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListModelsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listModelsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListModels");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(new JsonOperationMetadata()
.withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListModelsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists all retraining schedulers in your account, filtering by model name prefix and status.
*
*
* @param listRetrainingSchedulersRequest
* @return Result of the ListRetrainingSchedulers operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ListRetrainingSchedulers
* @see AWS API Documentation
*/
@Override
public ListRetrainingSchedulersResult listRetrainingSchedulers(ListRetrainingSchedulersRequest request) {
request = beforeClientExecution(request);
return executeListRetrainingSchedulers(request);
}
@SdkInternalApi
final ListRetrainingSchedulersResult executeListRetrainingSchedulers(ListRetrainingSchedulersRequest listRetrainingSchedulersRequest) {
ExecutionContext executionContext = createExecutionContext(listRetrainingSchedulersRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListRetrainingSchedulersRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(listRetrainingSchedulersRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListRetrainingSchedulers");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new ListRetrainingSchedulersResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists statistics about the data collected for each of the sensors that have been successfully ingested in the
* particular dataset. Can also be used to retreive Sensor Statistics for a previous ingestion job.
*
*
* @param listSensorStatisticsRequest
* @return Result of the ListSensorStatistics operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ListSensorStatistics
* @see AWS API Documentation
*/
@Override
public ListSensorStatisticsResult listSensorStatistics(ListSensorStatisticsRequest request) {
request = beforeClientExecution(request);
return executeListSensorStatistics(request);
}
@SdkInternalApi
final ListSensorStatisticsResult executeListSensorStatistics(ListSensorStatisticsRequest listSensorStatisticsRequest) {
ExecutionContext executionContext = createExecutionContext(listSensorStatisticsRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListSensorStatisticsRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listSensorStatisticsRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListSensorStatistics");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListSensorStatisticsResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Lists all the tags for a specified resource, including key and value.
*
*
* @param listTagsForResourceRequest
* @return Result of the ListTagsForResource operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.ListTagsForResource
* @see AWS API Documentation
*/
@Override
public ListTagsForResourceResult listTagsForResource(ListTagsForResourceRequest request) {
request = beforeClientExecution(request);
return executeListTagsForResource(request);
}
@SdkInternalApi
final ListTagsForResourceResult executeListTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest) {
ExecutionContext executionContext = createExecutionContext(listTagsForResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new ListTagsForResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(listTagsForResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "ListTagsForResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new ListTagsForResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Creates a resource control policy for a given resource.
*
*
* @param putResourcePolicyRequest
* @return Result of the PutResourcePolicy operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ServiceQuotaExceededException
* Resource limitations have been exceeded.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.PutResourcePolicy
* @see AWS API Documentation
*/
@Override
public PutResourcePolicyResult putResourcePolicy(PutResourcePolicyRequest request) {
request = beforeClientExecution(request);
return executePutResourcePolicy(request);
}
@SdkInternalApi
final PutResourcePolicyResult executePutResourcePolicy(PutResourcePolicyRequest putResourcePolicyRequest) {
ExecutionContext executionContext = createExecutionContext(putResourcePolicyRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new PutResourcePolicyRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(putResourcePolicyRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "PutResourcePolicy");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new PutResourcePolicyResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Starts a data ingestion job. Amazon Lookout for Equipment returns the job status.
*
*
* @param startDataIngestionJobRequest
* @return Result of the StartDataIngestionJob operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws ServiceQuotaExceededException
* Resource limitations have been exceeded.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.StartDataIngestionJob
* @see AWS API Documentation
*/
@Override
public StartDataIngestionJobResult startDataIngestionJob(StartDataIngestionJobRequest request) {
request = beforeClientExecution(request);
return executeStartDataIngestionJob(request);
}
@SdkInternalApi
final StartDataIngestionJobResult executeStartDataIngestionJob(StartDataIngestionJobRequest startDataIngestionJobRequest) {
ExecutionContext executionContext = createExecutionContext(startDataIngestionJobRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartDataIngestionJobRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(startDataIngestionJobRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StartDataIngestionJob");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory
.createResponseHandler(new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new StartDataIngestionJobResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Starts an inference scheduler.
*
*
* @param startInferenceSchedulerRequest
* @return Result of the StartInferenceScheduler operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.StartInferenceScheduler
* @see AWS API Documentation
*/
@Override
public StartInferenceSchedulerResult startInferenceScheduler(StartInferenceSchedulerRequest request) {
request = beforeClientExecution(request);
return executeStartInferenceScheduler(request);
}
@SdkInternalApi
final StartInferenceSchedulerResult executeStartInferenceScheduler(StartInferenceSchedulerRequest startInferenceSchedulerRequest) {
ExecutionContext executionContext = createExecutionContext(startInferenceSchedulerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartInferenceSchedulerRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(startInferenceSchedulerRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StartInferenceScheduler");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new StartInferenceSchedulerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Starts a retraining scheduler.
*
*
* @param startRetrainingSchedulerRequest
* @return Result of the StartRetrainingScheduler operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.StartRetrainingScheduler
* @see AWS API Documentation
*/
@Override
public StartRetrainingSchedulerResult startRetrainingScheduler(StartRetrainingSchedulerRequest request) {
request = beforeClientExecution(request);
return executeStartRetrainingScheduler(request);
}
@SdkInternalApi
final StartRetrainingSchedulerResult executeStartRetrainingScheduler(StartRetrainingSchedulerRequest startRetrainingSchedulerRequest) {
ExecutionContext executionContext = createExecutionContext(startRetrainingSchedulerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StartRetrainingSchedulerRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(startRetrainingSchedulerRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StartRetrainingScheduler");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new StartRetrainingSchedulerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Stops an inference scheduler.
*
*
* @param stopInferenceSchedulerRequest
* @return Result of the StopInferenceScheduler operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.StopInferenceScheduler
* @see AWS API Documentation
*/
@Override
public StopInferenceSchedulerResult stopInferenceScheduler(StopInferenceSchedulerRequest request) {
request = beforeClientExecution(request);
return executeStopInferenceScheduler(request);
}
@SdkInternalApi
final StopInferenceSchedulerResult executeStopInferenceScheduler(StopInferenceSchedulerRequest stopInferenceSchedulerRequest) {
ExecutionContext executionContext = createExecutionContext(stopInferenceSchedulerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StopInferenceSchedulerRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(stopInferenceSchedulerRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StopInferenceScheduler");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new StopInferenceSchedulerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Stops a retraining scheduler.
*
*
* @param stopRetrainingSchedulerRequest
* @return Result of the StopRetrainingScheduler operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.StopRetrainingScheduler
* @see AWS API Documentation
*/
@Override
public StopRetrainingSchedulerResult stopRetrainingScheduler(StopRetrainingSchedulerRequest request) {
request = beforeClientExecution(request);
return executeStopRetrainingScheduler(request);
}
@SdkInternalApi
final StopRetrainingSchedulerResult executeStopRetrainingScheduler(StopRetrainingSchedulerRequest stopRetrainingSchedulerRequest) {
ExecutionContext executionContext = createExecutionContext(stopRetrainingSchedulerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new StopRetrainingSchedulerRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(stopRetrainingSchedulerRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "StopRetrainingScheduler");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new StopRetrainingSchedulerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Associates a given tag to a resource in your account. A tag is a key-value pair which can be added to an Amazon
* Lookout for Equipment resource as metadata. Tags can be used for organizing your resources as well as helping you
* to search and filter by tag. Multiple tags can be added to a resource, either when you create it, or later. Up to
* 50 tags can be associated with each resource.
*
*
* @param tagResourceRequest
* @return Result of the TagResource operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ServiceQuotaExceededException
* Resource limitations have been exceeded.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.TagResource
* @see AWS
* API Documentation
*/
@Override
public TagResourceResult tagResource(TagResourceRequest request) {
request = beforeClientExecution(request);
return executeTagResource(request);
}
@SdkInternalApi
final TagResourceResult executeTagResource(TagResourceRequest tagResourceRequest) {
ExecutionContext executionContext = createExecutionContext(tagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new TagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(tagResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "TagResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new TagResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Removes a specific tag from a given resource. The tag is specified by its key.
*
*
* @param untagResourceRequest
* @return Result of the UntagResource operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.UntagResource
* @see AWS
* API Documentation
*/
@Override
public UntagResourceResult untagResource(UntagResourceRequest request) {
request = beforeClientExecution(request);
return executeUntagResource(request);
}
@SdkInternalApi
final UntagResourceResult executeUntagResource(UntagResourceRequest untagResourceRequest) {
ExecutionContext executionContext = createExecutionContext(untagResourceRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UntagResourceRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(untagResourceRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UntagResource");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UntagResourceResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Sets the active model version for a given machine learning model.
*
*
* @param updateActiveModelVersionRequest
* @return Result of the UpdateActiveModelVersion operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @sample AmazonLookoutEquipment.UpdateActiveModelVersion
* @see AWS API Documentation
*/
@Override
public UpdateActiveModelVersionResult updateActiveModelVersion(UpdateActiveModelVersionRequest request) {
request = beforeClientExecution(request);
return executeUpdateActiveModelVersion(request);
}
@SdkInternalApi
final UpdateActiveModelVersionResult executeUpdateActiveModelVersion(UpdateActiveModelVersionRequest updateActiveModelVersionRequest) {
ExecutionContext executionContext = createExecutionContext(updateActiveModelVersionRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateActiveModelVersionRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateActiveModelVersionRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateActiveModelVersion");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateActiveModelVersionResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates an inference scheduler.
*
*
* @param updateInferenceSchedulerRequest
* @return Result of the UpdateInferenceScheduler operation returned by the service.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.UpdateInferenceScheduler
* @see AWS API Documentation
*/
@Override
public UpdateInferenceSchedulerResult updateInferenceScheduler(UpdateInferenceSchedulerRequest request) {
request = beforeClientExecution(request);
return executeUpdateInferenceScheduler(request);
}
@SdkInternalApi
final UpdateInferenceSchedulerResult executeUpdateInferenceScheduler(UpdateInferenceSchedulerRequest updateInferenceSchedulerRequest) {
ExecutionContext executionContext = createExecutionContext(updateInferenceSchedulerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateInferenceSchedulerRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateInferenceSchedulerRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateInferenceScheduler");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateInferenceSchedulerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates the label group.
*
*
* @param updateLabelGroupRequest
* @return Result of the UpdateLabelGroup operation returned by the service.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.UpdateLabelGroup
* @see AWS API Documentation
*/
@Override
public UpdateLabelGroupResult updateLabelGroup(UpdateLabelGroupRequest request) {
request = beforeClientExecution(request);
return executeUpdateLabelGroup(request);
}
@SdkInternalApi
final UpdateLabelGroupResult executeUpdateLabelGroup(UpdateLabelGroupRequest updateLabelGroupRequest) {
ExecutionContext executionContext = createExecutionContext(updateLabelGroupRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateLabelGroupRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateLabelGroupRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateLabelGroup");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateLabelGroupResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates a model in the account.
*
*
* @param updateModelRequest
* @return Result of the UpdateModel operation returned by the service.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.UpdateModel
* @see AWS
* API Documentation
*/
@Override
public UpdateModelResult updateModel(UpdateModelRequest request) {
request = beforeClientExecution(request);
return executeUpdateModel(request);
}
@SdkInternalApi
final UpdateModelResult executeUpdateModel(UpdateModelRequest updateModelRequest) {
ExecutionContext executionContext = createExecutionContext(updateModelRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateModelRequestProtocolMarshaller(protocolFactory).marshall(super.beforeMarshalling(updateModelRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateModel");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false), new UpdateModelResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
*
* Updates a retraining scheduler.
*
*
* @param updateRetrainingSchedulerRequest
* @return Result of the UpdateRetrainingScheduler operation returned by the service.
* @throws ValidationException
* The input fails to satisfy constraints specified by Amazon Lookout for Equipment or a related Amazon Web
* Services service that's being utilized.
* @throws ResourceNotFoundException
* The resource requested could not be found. Verify the resource ID and retry your request.
* @throws ConflictException
* The request could not be completed due to a conflict with the current state of the target resource.
* @throws ThrottlingException
* The request was denied due to request throttling.
* @throws AccessDeniedException
* The request could not be completed because you do not have access to the resource.
* @throws InternalServerException
* Processing of the request has failed because of an unknown error, exception or failure.
* @sample AmazonLookoutEquipment.UpdateRetrainingScheduler
* @see AWS API Documentation
*/
@Override
public UpdateRetrainingSchedulerResult updateRetrainingScheduler(UpdateRetrainingSchedulerRequest request) {
request = beforeClientExecution(request);
return executeUpdateRetrainingScheduler(request);
}
@SdkInternalApi
final UpdateRetrainingSchedulerResult executeUpdateRetrainingScheduler(UpdateRetrainingSchedulerRequest updateRetrainingSchedulerRequest) {
ExecutionContext executionContext = createExecutionContext(updateRetrainingSchedulerRequest);
AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
awsRequestMetrics.startEvent(Field.ClientExecuteTime);
Request request = null;
Response response = null;
try {
awsRequestMetrics.startEvent(Field.RequestMarshallTime);
try {
request = new UpdateRetrainingSchedulerRequestProtocolMarshaller(protocolFactory).marshall(super
.beforeMarshalling(updateRetrainingSchedulerRequest));
// Binds the request metrics to the current request.
request.setAWSRequestMetrics(awsRequestMetrics);
request.addHandlerContext(HandlerContextKey.CLIENT_ENDPOINT, endpoint);
request.addHandlerContext(HandlerContextKey.ENDPOINT_OVERRIDDEN, isEndpointOverridden());
request.addHandlerContext(HandlerContextKey.SIGNING_REGION, getSigningRegion());
request.addHandlerContext(HandlerContextKey.SERVICE_ID, "LookoutEquipment");
request.addHandlerContext(HandlerContextKey.OPERATION_NAME, "UpdateRetrainingScheduler");
request.addHandlerContext(HandlerContextKey.ADVANCED_CONFIG, advancedConfig);
} finally {
awsRequestMetrics.endEvent(Field.RequestMarshallTime);
}
HttpResponseHandler> responseHandler = protocolFactory.createResponseHandler(
new JsonOperationMetadata().withPayloadJson(true).withHasStreamingSuccessResponse(false),
new UpdateRetrainingSchedulerResultJsonUnmarshaller());
response = invoke(request, responseHandler, executionContext);
return response.getAwsResponse();
} finally {
endClientExecution(awsRequestMetrics, request, response);
}
}
/**
* Returns additional metadata for a previously executed successful, request, typically used for debugging issues
* where a service isn't acting as expected. This data isn't considered part of the result data returned by an
* operation, so it's available through this separate, diagnostic interface.
*
* Response metadata is only cached for a limited period of time, so if you need to access this extra diagnostic
* information for an executed request, you should use this method to retrieve it as soon as possible after
* executing the request.
*
* @param request
* The originally executed request
*
* @return The response metadata for the specified request, or null if none is available.
*/
public ResponseMetadata getCachedResponseMetadata(AmazonWebServiceRequest request) {
return client.getResponseMetadataForRequest(request);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext) {
return invoke(request, responseHandler, executionContext, null, null);
}
/**
* Normal invoke with authentication. Credentials are required and may be overriden at the request level.
**/
private Response invoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI cachedEndpoint, URI uriFromEndpointTrait) {
executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(request.getOriginalRequest(), awsCredentialsProvider));
return doInvoke(request, responseHandler, executionContext, cachedEndpoint, uriFromEndpointTrait);
}
/**
* Invoke with no authentication. Credentials are not required and any credentials set on the client or request will
* be ignored for this operation.
**/
private Response anonymousInvoke(Request request,
HttpResponseHandler> responseHandler, ExecutionContext executionContext) {
return doInvoke(request, responseHandler, executionContext, null, null);
}
/**
* Invoke the request using the http client. Assumes credentials (or lack thereof) have been configured in the
* ExecutionContext beforehand.
**/
private Response doInvoke(Request request, HttpResponseHandler> responseHandler,
ExecutionContext executionContext, URI discoveredEndpoint, URI uriFromEndpointTrait) {
if (discoveredEndpoint != null) {
request.setEndpoint(discoveredEndpoint);
request.getOriginalRequest().getRequestClientOptions().appendUserAgent("endpoint-discovery");
} else if (uriFromEndpointTrait != null) {
request.setEndpoint(uriFromEndpointTrait);
} else {
request.setEndpoint(endpoint);
}
request.setTimeOffset(timeOffset);
HttpResponseHandler errorResponseHandler = protocolFactory.createErrorResponseHandler(new JsonErrorResponseMetadata());
return client.execute(request, responseHandler, errorResponseHandler, executionContext);
}
@com.amazonaws.annotation.SdkInternalApi
static com.amazonaws.protocol.json.SdkJsonProtocolFactory getProtocolFactory() {
return protocolFactory;
}
@Override
public void shutdown() {
super.shutdown();
}
}