software.amazon.awssdk.services.cloudwatchevents.DefaultCloudWatchEventsClient Maven / Gradle / Ivy
Show all versions of cloudwatchevents Show documentation
/*
* Copyright 2014-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package software.amazon.awssdk.services.cloudwatchevents;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.annotations.SdkInternalApi;
import software.amazon.awssdk.awscore.client.handler.AwsSyncClientHandler;
import software.amazon.awssdk.awscore.exception.AwsServiceException;
import software.amazon.awssdk.core.client.config.SdkClientConfiguration;
import software.amazon.awssdk.core.client.handler.ClientExecutionParams;
import software.amazon.awssdk.core.client.handler.SyncClientHandler;
import software.amazon.awssdk.core.exception.SdkClientException;
import software.amazon.awssdk.core.http.HttpResponseHandler;
import software.amazon.awssdk.protocols.core.ExceptionMetadata;
import software.amazon.awssdk.protocols.json.AwsJsonProtocol;
import software.amazon.awssdk.protocols.json.AwsJsonProtocolFactory;
import software.amazon.awssdk.protocols.json.BaseAwsJsonProtocolFactory;
import software.amazon.awssdk.protocols.json.JsonOperationMetadata;
import software.amazon.awssdk.services.cloudwatchevents.model.CloudWatchEventsException;
import software.amazon.awssdk.services.cloudwatchevents.model.ConcurrentModificationException;
import software.amazon.awssdk.services.cloudwatchevents.model.DeleteRuleRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.DeleteRuleResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.DescribeEventBusRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.DescribeEventBusResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.DescribeRuleRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.DescribeRuleResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.DisableRuleRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.DisableRuleResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.EnableRuleRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.EnableRuleResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.InternalException;
import software.amazon.awssdk.services.cloudwatchevents.model.InvalidEventPatternException;
import software.amazon.awssdk.services.cloudwatchevents.model.LimitExceededException;
import software.amazon.awssdk.services.cloudwatchevents.model.ListRuleNamesByTargetRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.ListRuleNamesByTargetResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.ListRulesRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.ListRulesResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.ListTagsForResourceRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.ListTagsForResourceResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.ListTargetsByRuleRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.ListTargetsByRuleResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.ManagedRuleException;
import software.amazon.awssdk.services.cloudwatchevents.model.PolicyLengthExceededException;
import software.amazon.awssdk.services.cloudwatchevents.model.PutEventsRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.PutEventsResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.PutPermissionRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.PutPermissionResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.PutRuleRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.PutRuleResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.PutTargetsRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.PutTargetsResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.RemovePermissionRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.RemovePermissionResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.RemoveTargetsRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.RemoveTargetsResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.ResourceNotFoundException;
import software.amazon.awssdk.services.cloudwatchevents.model.TagResourceRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.TagResourceResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.TestEventPatternRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.TestEventPatternResponse;
import software.amazon.awssdk.services.cloudwatchevents.model.UntagResourceRequest;
import software.amazon.awssdk.services.cloudwatchevents.model.UntagResourceResponse;
import software.amazon.awssdk.services.cloudwatchevents.transform.DeleteRuleRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.DescribeEventBusRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.DescribeRuleRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.DisableRuleRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.EnableRuleRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.ListRuleNamesByTargetRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.ListRulesRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.ListTagsForResourceRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.ListTargetsByRuleRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.PutEventsRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.PutPermissionRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.PutRuleRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.PutTargetsRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.RemovePermissionRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.RemoveTargetsRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.TagResourceRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.TestEventPatternRequestMarshaller;
import software.amazon.awssdk.services.cloudwatchevents.transform.UntagResourceRequestMarshaller;
/**
* Internal implementation of {@link CloudWatchEventsClient}.
*
* @see CloudWatchEventsClient#builder()
*/
@Generated("software.amazon.awssdk:codegen")
@SdkInternalApi
final class DefaultCloudWatchEventsClient implements CloudWatchEventsClient {
private final SyncClientHandler clientHandler;
private final AwsJsonProtocolFactory protocolFactory;
private final SdkClientConfiguration clientConfiguration;
protected DefaultCloudWatchEventsClient(SdkClientConfiguration clientConfiguration) {
this.clientHandler = new AwsSyncClientHandler(clientConfiguration);
this.clientConfiguration = clientConfiguration;
this.protocolFactory = init(AwsJsonProtocolFactory.builder()).build();
}
@Override
public final String serviceName() {
return SERVICE_NAME;
}
/**
*
* Deletes the specified rule.
*
*
* Before you can delete the rule, you must remove all targets, using RemoveTargets.
*
*
* When you delete a rule, incoming events might continue to match to the deleted rule. Allow a short period of time
* for changes to take effect.
*
*
* Managed rules are rules created and managed by another AWS service on your behalf. These rules are created by
* those other AWS services to support functionality in those services. You can delete these rules using the
* Force option, but you should do so only if you are sure the other service is not still using that
* rule.
*
*
* @param deleteRuleRequest
* @return Result of the DeleteRule operation returned by the service.
* @throws ConcurrentModificationException
* There is concurrent modification on a rule or target.
* @throws ManagedRuleException
* This rule was created by an AWS service on behalf of your account. It is managed by that service. If you
* see this error in response to DeleteRule or RemoveTargets, you can use the
* Force parameter in those calls to delete the rule or remove targets from the rule. You
* cannot modify these managed rules by using DisableRule, EnableRule,
* PutTargets, PutRule, TagResource, or UntagResource.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.DeleteRule
* @see AWS API
* Documentation
*/
@Override
public DeleteRuleResponse deleteRule(DeleteRuleRequest deleteRuleRequest) throws ConcurrentModificationException,
ManagedRuleException, InternalException, AwsServiceException, SdkClientException, CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DeleteRuleResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DeleteRule").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(deleteRuleRequest)
.withMarshaller(new DeleteRuleRequestMarshaller(protocolFactory)));
}
/**
*
* Displays the external AWS accounts that are permitted to write events to your account using your account's event
* bus, and the associated policy. To enable your account to receive events from other accounts, use
* PutPermission.
*
*
* @param describeEventBusRequest
* @return Result of the DescribeEventBus operation returned by the service.
* @throws ResourceNotFoundException
* An entity that you specified does not exist.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.DescribeEventBus
* @see AWS API
* Documentation
*/
@Override
public DescribeEventBusResponse describeEventBus(DescribeEventBusRequest describeEventBusRequest)
throws ResourceNotFoundException, InternalException, AwsServiceException, SdkClientException,
CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DescribeEventBusResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DescribeEventBus").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(describeEventBusRequest)
.withMarshaller(new DescribeEventBusRequestMarshaller(protocolFactory)));
}
/**
*
* Describes the specified rule.
*
*
* DescribeRule does not list the targets of a rule. To see the targets associated with a rule, use
* ListTargetsByRule.
*
*
* @param describeRuleRequest
* @return Result of the DescribeRule operation returned by the service.
* @throws ResourceNotFoundException
* An entity that you specified does not exist.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.DescribeRule
* @see AWS API
* Documentation
*/
@Override
public DescribeRuleResponse describeRule(DescribeRuleRequest describeRuleRequest) throws ResourceNotFoundException,
InternalException, AwsServiceException, SdkClientException, CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DescribeRuleResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DescribeRule").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(describeRuleRequest)
.withMarshaller(new DescribeRuleRequestMarshaller(protocolFactory)));
}
/**
*
* Disables the specified rule. A disabled rule won't match any events, and won't self-trigger if it has a schedule
* expression.
*
*
* When you disable a rule, incoming events might continue to match to the disabled rule. Allow a short period of
* time for changes to take effect.
*
*
* @param disableRuleRequest
* @return Result of the DisableRule operation returned by the service.
* @throws ResourceNotFoundException
* An entity that you specified does not exist.
* @throws ConcurrentModificationException
* There is concurrent modification on a rule or target.
* @throws ManagedRuleException
* This rule was created by an AWS service on behalf of your account. It is managed by that service. If you
* see this error in response to DeleteRule or RemoveTargets, you can use the
* Force parameter in those calls to delete the rule or remove targets from the rule. You
* cannot modify these managed rules by using DisableRule, EnableRule,
* PutTargets, PutRule, TagResource, or UntagResource.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.DisableRule
* @see AWS API
* Documentation
*/
@Override
public DisableRuleResponse disableRule(DisableRuleRequest disableRuleRequest) throws ResourceNotFoundException,
ConcurrentModificationException, ManagedRuleException, InternalException, AwsServiceException, SdkClientException,
CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
DisableRuleResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("DisableRule").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(disableRuleRequest)
.withMarshaller(new DisableRuleRequestMarshaller(protocolFactory)));
}
/**
*
* Enables the specified rule. If the rule does not exist, the operation fails.
*
*
* When you enable a rule, incoming events might not immediately start matching to a newly enabled rule. Allow a
* short period of time for changes to take effect.
*
*
* @param enableRuleRequest
* @return Result of the EnableRule operation returned by the service.
* @throws ResourceNotFoundException
* An entity that you specified does not exist.
* @throws ConcurrentModificationException
* There is concurrent modification on a rule or target.
* @throws ManagedRuleException
* This rule was created by an AWS service on behalf of your account. It is managed by that service. If you
* see this error in response to DeleteRule or RemoveTargets, you can use the
* Force parameter in those calls to delete the rule or remove targets from the rule. You
* cannot modify these managed rules by using DisableRule, EnableRule,
* PutTargets, PutRule, TagResource, or UntagResource.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.EnableRule
* @see AWS API
* Documentation
*/
@Override
public EnableRuleResponse enableRule(EnableRuleRequest enableRuleRequest) throws ResourceNotFoundException,
ConcurrentModificationException, ManagedRuleException, InternalException, AwsServiceException, SdkClientException,
CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
EnableRuleResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("EnableRule").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(enableRuleRequest)
.withMarshaller(new EnableRuleRequestMarshaller(protocolFactory)));
}
/**
*
* Lists the rules for the specified target. You can see which of the rules in Amazon CloudWatch Events can invoke a
* specific target in your account.
*
*
* @param listRuleNamesByTargetRequest
* @return Result of the ListRuleNamesByTarget operation returned by the service.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.ListRuleNamesByTarget
* @see AWS
* API Documentation
*/
@Override
public ListRuleNamesByTargetResponse listRuleNamesByTarget(ListRuleNamesByTargetRequest listRuleNamesByTargetRequest)
throws InternalException, AwsServiceException, SdkClientException, CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, ListRuleNamesByTargetResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("ListRuleNamesByTarget").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(listRuleNamesByTargetRequest)
.withMarshaller(new ListRuleNamesByTargetRequestMarshaller(protocolFactory)));
}
/**
*
* Lists your Amazon CloudWatch Events rules. You can either list all the rules or you can provide a prefix to match
* to the rule names.
*
*
* ListRules does not list the targets of a rule. To see the targets associated with a rule, use
* ListTargetsByRule.
*
*
* @param listRulesRequest
* @return Result of the ListRules operation returned by the service.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.ListRules
* @see AWS API
* Documentation
*/
@Override
public ListRulesResponse listRules(ListRulesRequest listRulesRequest) throws InternalException, AwsServiceException,
SdkClientException, CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
ListRulesResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("ListRules").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(listRulesRequest)
.withMarshaller(new ListRulesRequestMarshaller(protocolFactory)));
}
/**
*
* Displays the tags associated with a CloudWatch Events resource. In CloudWatch Events, rules can be tagged.
*
*
* @param listTagsForResourceRequest
* @return Result of the ListTagsForResource operation returned by the service.
* @throws ResourceNotFoundException
* An entity that you specified does not exist.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.ListTagsForResource
* @see AWS API
* Documentation
*/
@Override
public ListTagsForResourceResponse listTagsForResource(ListTagsForResourceRequest listTagsForResourceRequest)
throws ResourceNotFoundException, InternalException, AwsServiceException, SdkClientException,
CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(
operationMetadata, ListTagsForResourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("ListTagsForResource").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(listTagsForResourceRequest)
.withMarshaller(new ListTagsForResourceRequestMarshaller(protocolFactory)));
}
/**
*
* Lists the targets assigned to the specified rule.
*
*
* @param listTargetsByRuleRequest
* @return Result of the ListTargetsByRule operation returned by the service.
* @throws ResourceNotFoundException
* An entity that you specified does not exist.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.ListTargetsByRule
* @see AWS API
* Documentation
*/
@Override
public ListTargetsByRuleResponse listTargetsByRule(ListTargetsByRuleRequest listTargetsByRuleRequest)
throws ResourceNotFoundException, InternalException, AwsServiceException, SdkClientException,
CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
ListTargetsByRuleResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("ListTargetsByRule").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(listTargetsByRuleRequest)
.withMarshaller(new ListTargetsByRuleRequestMarshaller(protocolFactory)));
}
/**
*
* Sends custom events to Amazon CloudWatch Events so that they can be matched to rules.
*
*
* @param putEventsRequest
* @return Result of the PutEvents operation returned by the service.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.PutEvents
* @see AWS API
* Documentation
*/
@Override
public PutEventsResponse putEvents(PutEventsRequest putEventsRequest) throws InternalException, AwsServiceException,
SdkClientException, CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
PutEventsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("PutEvents").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(putEventsRequest)
.withMarshaller(new PutEventsRequestMarshaller(protocolFactory)));
}
/**
*
* Running PutPermission permits the specified AWS account or AWS organization to put events to your
* account's default event bus. CloudWatch Events rules in your account are triggered by these events
* arriving to your default event bus.
*
*
* For another account to send events to your account, that external account must have a CloudWatch Events rule with
* your account's default event bus as a target.
*
*
* To enable multiple AWS accounts to put events to your default event bus, run PutPermission once for
* each of these accounts. Or, if all the accounts are members of the same AWS organization, you can run
* PutPermission once specifying Principal as "*" and specifying the AWS organization ID
* in Condition, to grant permissions to all accounts in that organization.
*
*
* If you grant permissions using an organization, then accounts in that organization must specify a
* RoleArn with proper permissions when they use PutTarget to add your account's event bus
* as a target. For more information, see Sending and Receiving Events Between AWS Accounts in the Amazon CloudWatch Events User Guide.
*
*
* The permission policy on the default event bus cannot exceed 10 KB in size.
*
*
* @param putPermissionRequest
* @return Result of the PutPermission operation returned by the service.
* @throws ResourceNotFoundException
* An entity that you specified does not exist.
* @throws PolicyLengthExceededException
* The event bus policy is too long. For more information, see the limits.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws ConcurrentModificationException
* There is concurrent modification on a rule or target.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.PutPermission
* @see AWS API
* Documentation
*/
@Override
public PutPermissionResponse putPermission(PutPermissionRequest putPermissionRequest) throws ResourceNotFoundException,
PolicyLengthExceededException, InternalException, ConcurrentModificationException, AwsServiceException,
SdkClientException, CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
PutPermissionResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("PutPermission").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(putPermissionRequest)
.withMarshaller(new PutPermissionRequestMarshaller(protocolFactory)));
}
/**
*
* Creates or updates the specified rule. Rules are enabled by default, or based on value of the state. You can
* disable a rule using DisableRule.
*
*
* If you are updating an existing rule, the rule is replaced with what you specify in this PutRule
* command. If you omit arguments in PutRule, the old values for those arguments are not kept. Instead,
* they are replaced with null values.
*
*
* When you create or update a rule, incoming events might not immediately start matching to new or updated rules.
* Allow a short period of time for changes to take effect.
*
*
* A rule must contain at least an EventPattern or ScheduleExpression. Rules with EventPatterns are triggered when a
* matching event is observed. Rules with ScheduleExpressions self-trigger based on the given schedule. A rule can
* have both an EventPattern and a ScheduleExpression, in which case the rule triggers on matching events as well as
* on a schedule.
*
*
* When you initially create a rule, you can optionally assign one or more tags to the rule. Tags can help you
* organize and categorize your resources. You can also use them to scope user permissions, by granting a user
* permission to access or change only rules with certain tag values. To use the PutRule operation and
* assign tags, you must have both the events:PutRule and events:TagResource permissions.
*
*
* If you are updating an existing rule, any tags you specify in the PutRule operation are ignored. To
* update the tags of an existing rule, use TagResource and UntagResource.
*
*
* Most services in AWS treat : or / as the same character in Amazon Resource Names (ARNs). However, CloudWatch
* Events uses an exact match in event patterns and rules. Be sure to use the correct ARN characters when creating
* event patterns so that they match the ARN syntax in the event you want to match.
*
*
* In CloudWatch Events, it is possible to create rules that lead to infinite loops, where a rule is fired
* repeatedly. For example, a rule might detect that ACLs have changed on an S3 bucket, and trigger software to
* change them to the desired state. If the rule is not written carefully, the subsequent change to the ACLs fires
* the rule again, creating an infinite loop.
*
*
* To prevent this, write the rules so that the triggered actions do not re-fire the same rule. For example, your
* rule could fire only if ACLs are found to be in a bad state, instead of after any change.
*
*
* An infinite loop can quickly cause higher than expected charges. We recommend that you use budgeting, which
* alerts you when charges exceed your specified limit. For more information, see Managing Your
* Costs with Budgets.
*
*
* @param putRuleRequest
* @return Result of the PutRule operation returned by the service.
* @throws InvalidEventPatternException
* The event pattern is not valid.
* @throws LimitExceededException
* You tried to create more rules or add more targets to a rule than is allowed.
* @throws ConcurrentModificationException
* There is concurrent modification on a rule or target.
* @throws ManagedRuleException
* This rule was created by an AWS service on behalf of your account. It is managed by that service. If you
* see this error in response to DeleteRule or RemoveTargets, you can use the
* Force parameter in those calls to delete the rule or remove targets from the rule. You
* cannot modify these managed rules by using DisableRule, EnableRule,
* PutTargets, PutRule, TagResource, or UntagResource.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.PutRule
* @see AWS API
* Documentation
*/
@Override
public PutRuleResponse putRule(PutRuleRequest putRuleRequest) throws InvalidEventPatternException, LimitExceededException,
ConcurrentModificationException, ManagedRuleException, InternalException, AwsServiceException, SdkClientException,
CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
PutRuleResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams().withOperationName("PutRule")
.withResponseHandler(responseHandler).withErrorResponseHandler(errorResponseHandler).withInput(putRuleRequest)
.withMarshaller(new PutRuleRequestMarshaller(protocolFactory)));
}
/**
*
* Adds the specified targets to the specified rule, or updates the targets if they are already associated with the
* rule.
*
*
* Targets are the resources that are invoked when a rule is triggered.
*
*
* You can configure the following as targets for CloudWatch Events:
*
*
* -
*
* EC2 instances
*
*
* -
*
* SSM Run Command
*
*
* -
*
* SSM Automation
*
*
* -
*
* AWS Lambda functions
*
*
* -
*
* Data streams in Amazon Kinesis Data Streams
*
*
* -
*
* Data delivery streams in Amazon Kinesis Data Firehose
*
*
* -
*
* Amazon ECS tasks
*
*
* -
*
* AWS Step Functions state machines
*
*
* -
*
* AWS Batch jobs
*
*
* -
*
* AWS CodeBuild projects
*
*
* -
*
* Pipelines in AWS CodePipeline
*
*
* -
*
* Amazon Inspector assessment templates
*
*
* -
*
* Amazon SNS topics
*
*
* -
*
* Amazon SQS queues, including FIFO queues
*
*
* -
*
* The default event bus of another AWS account
*
*
*
*
* Creating rules with built-in targets is supported only in the AWS Management Console. The built-in targets are
* EC2 CreateSnapshot API call, EC2 RebootInstances API call,
* EC2 StopInstances API call, and EC2 TerminateInstances API call.
*
*
* For some target types, PutTargets provides target-specific parameters. If the target is a Kinesis
* data stream, you can optionally specify which shard the event goes to by using the KinesisParameters
* argument. To invoke a command on multiple EC2 instances with one rule, you can use the
* RunCommandParameters field.
*
*
* To be able to make API calls against the resources that you own, Amazon CloudWatch Events needs the appropriate
* permissions. For AWS Lambda and Amazon SNS resources, CloudWatch Events relies on resource-based policies. For
* EC2 instances, Kinesis data streams, and AWS Step Functions state machines, CloudWatch Events relies on IAM roles
* that you specify in the RoleARN argument in PutTargets. For more information, see Authentication
* and Access Control in the Amazon CloudWatch Events User Guide.
*
*
* If another AWS account is in the same region and has granted you permission (using PutPermission),
* you can send events to that account. Set that account's event bus as a target of the rules in your account. To
* send the matched events to the other account, specify that account's event bus as the Arn value when
* you run PutTargets. If your account sends events to another account, your account is charged for
* each sent event. Each event sent to another account is charged as a custom event. The account receiving the event
* is not charged. For more information, see Amazon CloudWatch
* Pricing.
*
*
* If you are setting the event bus of another account as the target, and that account granted permission to your
* account through an organization instead of directly by the account ID, then you must specify a
* RoleArn with proper permissions in the Target structure. For more information, see
* Sending and Receiving Events Between AWS Accounts in the Amazon CloudWatch Events User Guide.
*
*
* For more information about enabling cross-account events, see PutPermission.
*
*
* Input, InputPath, and InputTransformer are mutually exclusive and optional parameters of a
* target. When a rule is triggered due to a matched event:
*
*
* -
*
* If none of the following arguments are specified for a target, then the entire event is passed to the target in
* JSON format (unless the target is Amazon EC2 Run Command or Amazon ECS task, in which case nothing from the event
* is passed to the target).
*
*
* -
*
* If Input is specified in the form of valid JSON, then the matched event is overridden with this constant.
*
*
* -
*
* If InputPath is specified in the form of JSONPath (for example, $.detail), then only the
* part of the event specified in the path is passed to the target (for example, only the detail part of the event
* is passed).
*
*
* -
*
* If InputTransformer is specified, then one or more specified JSONPaths are extracted from the event and
* used as values in a template that you specify as the input to the target.
*
*
*
*
* When you specify InputPath or InputTransformer, you must use JSON dot notation, not
* bracket notation.
*
*
* When you add targets to a rule and the associated rule triggers soon after, new or updated targets might not be
* immediately invoked. Allow a short period of time for changes to take effect.
*
*
* This action can partially fail if too many requests are made at the same time. If that happens,
* FailedEntryCount is non-zero in the response and each entry in FailedEntries provides
* the ID of the failed target and the error code.
*
*
* @param putTargetsRequest
* @return Result of the PutTargets operation returned by the service.
* @throws ResourceNotFoundException
* An entity that you specified does not exist.
* @throws ConcurrentModificationException
* There is concurrent modification on a rule or target.
* @throws LimitExceededException
* You tried to create more rules or add more targets to a rule than is allowed.
* @throws ManagedRuleException
* This rule was created by an AWS service on behalf of your account. It is managed by that service. If you
* see this error in response to DeleteRule or RemoveTargets, you can use the
* Force parameter in those calls to delete the rule or remove targets from the rule. You
* cannot modify these managed rules by using DisableRule, EnableRule,
* PutTargets, PutRule, TagResource, or UntagResource.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.PutTargets
* @see AWS API
* Documentation
*/
@Override
public PutTargetsResponse putTargets(PutTargetsRequest putTargetsRequest) throws ResourceNotFoundException,
ConcurrentModificationException, LimitExceededException, ManagedRuleException, InternalException,
AwsServiceException, SdkClientException, CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
PutTargetsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("PutTargets").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(putTargetsRequest)
.withMarshaller(new PutTargetsRequestMarshaller(protocolFactory)));
}
/**
*
* Revokes the permission of another AWS account to be able to put events to your default event bus. Specify the
* account to revoke by the StatementId value that you associated with the account when you granted it
* permission with PutPermission. You can find the StatementId by using
* DescribeEventBus.
*
*
* @param removePermissionRequest
* @return Result of the RemovePermission operation returned by the service.
* @throws ResourceNotFoundException
* An entity that you specified does not exist.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws ConcurrentModificationException
* There is concurrent modification on a rule or target.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.RemovePermission
* @see AWS API
* Documentation
*/
@Override
public RemovePermissionResponse removePermission(RemovePermissionRequest removePermissionRequest)
throws ResourceNotFoundException, InternalException, ConcurrentModificationException, AwsServiceException,
SdkClientException, CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
RemovePermissionResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("RemovePermission").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(removePermissionRequest)
.withMarshaller(new RemovePermissionRequestMarshaller(protocolFactory)));
}
/**
*
* Removes the specified targets from the specified rule. When the rule is triggered, those targets are no longer be
* invoked.
*
*
* When you remove a target, when the associated rule triggers, removed targets might continue to be invoked. Allow
* a short period of time for changes to take effect.
*
*
* This action can partially fail if too many requests are made at the same time. If that happens,
* FailedEntryCount is non-zero in the response and each entry in FailedEntries provides
* the ID of the failed target and the error code.
*
*
* @param removeTargetsRequest
* @return Result of the RemoveTargets operation returned by the service.
* @throws ResourceNotFoundException
* An entity that you specified does not exist.
* @throws ConcurrentModificationException
* There is concurrent modification on a rule or target.
* @throws ManagedRuleException
* This rule was created by an AWS service on behalf of your account. It is managed by that service. If you
* see this error in response to DeleteRule or RemoveTargets, you can use the
* Force parameter in those calls to delete the rule or remove targets from the rule. You
* cannot modify these managed rules by using DisableRule, EnableRule,
* PutTargets, PutRule, TagResource, or UntagResource.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.RemoveTargets
* @see AWS API
* Documentation
*/
@Override
public RemoveTargetsResponse removeTargets(RemoveTargetsRequest removeTargetsRequest) throws ResourceNotFoundException,
ConcurrentModificationException, ManagedRuleException, InternalException, AwsServiceException, SdkClientException,
CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
RemoveTargetsResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("RemoveTargets").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(removeTargetsRequest)
.withMarshaller(new RemoveTargetsRequestMarshaller(protocolFactory)));
}
/**
*
* Assigns one or more tags (key-value pairs) to the specified CloudWatch Events resource. Tags can help you
* organize and categorize your resources. You can also use them to scope user permissions by granting a user
* permission to access or change only resources with certain tag values. In CloudWatch Events, rules can be tagged.
*
*
* Tags don't have any semantic meaning to AWS and are interpreted strictly as strings of characters.
*
*
* You can use the TagResource action with a rule that already has tags. If you specify a new tag key
* for the rule, this tag is appended to the list of tags associated with the rule. If you specify a tag key that is
* already associated with the rule, the new tag value that you specify replaces the previous value for that tag.
*
*
* You can associate as many as 50 tags with a resource.
*
*
* @param tagResourceRequest
* @return Result of the TagResource operation returned by the service.
* @throws ResourceNotFoundException
* An entity that you specified does not exist.
* @throws ConcurrentModificationException
* There is concurrent modification on a rule or target.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws ManagedRuleException
* This rule was created by an AWS service on behalf of your account. It is managed by that service. If you
* see this error in response to DeleteRule or RemoveTargets, you can use the
* Force parameter in those calls to delete the rule or remove targets from the rule. You
* cannot modify these managed rules by using DisableRule, EnableRule,
* PutTargets, PutRule, TagResource, or UntagResource.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.TagResource
* @see AWS API
* Documentation
*/
@Override
public TagResourceResponse tagResource(TagResourceRequest tagResourceRequest) throws ResourceNotFoundException,
ConcurrentModificationException, InternalException, ManagedRuleException, AwsServiceException, SdkClientException,
CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
TagResourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("TagResource").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(tagResourceRequest)
.withMarshaller(new TagResourceRequestMarshaller(protocolFactory)));
}
/**
*
* Tests whether the specified event pattern matches the provided event.
*
*
* Most services in AWS treat : or / as the same character in Amazon Resource Names (ARNs). However, CloudWatch
* Events uses an exact match in event patterns and rules. Be sure to use the correct ARN characters when creating
* event patterns so that they match the ARN syntax in the event you want to match.
*
*
* @param testEventPatternRequest
* @return Result of the TestEventPattern operation returned by the service.
* @throws InvalidEventPatternException
* The event pattern is not valid.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.TestEventPattern
* @see AWS API
* Documentation
*/
@Override
public TestEventPatternResponse testEventPattern(TestEventPatternRequest testEventPatternRequest)
throws InvalidEventPatternException, InternalException, AwsServiceException, SdkClientException,
CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
TestEventPatternResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("TestEventPattern").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(testEventPatternRequest)
.withMarshaller(new TestEventPatternRequestMarshaller(protocolFactory)));
}
/**
*
* Removes one or more tags from the specified CloudWatch Events resource. In CloudWatch Events, rules can be
* tagged.
*
*
* @param untagResourceRequest
* @return Result of the UntagResource operation returned by the service.
* @throws ResourceNotFoundException
* An entity that you specified does not exist.
* @throws InternalException
* This exception occurs due to unexpected causes.
* @throws ConcurrentModificationException
* There is concurrent modification on a rule or target.
* @throws ManagedRuleException
* This rule was created by an AWS service on behalf of your account. It is managed by that service. If you
* see this error in response to DeleteRule or RemoveTargets, you can use the
* Force parameter in those calls to delete the rule or remove targets from the rule. You
* cannot modify these managed rules by using DisableRule, EnableRule,
* PutTargets, PutRule, TagResource, or UntagResource.
* @throws SdkException
* Base class for all exceptions that can be thrown by the SDK (both service and client). Can be used for
* catch all scenarios.
* @throws SdkClientException
* If any client side error occurs such as an IO related failure, failure to get credentials, etc.
* @throws CloudWatchEventsException
* Base class for all service exceptions. Unknown exceptions will be thrown as an instance of this type.
* @sample CloudWatchEventsClient.UntagResource
* @see AWS API
* Documentation
*/
@Override
public UntagResourceResponse untagResource(UntagResourceRequest untagResourceRequest) throws ResourceNotFoundException,
InternalException, ConcurrentModificationException, ManagedRuleException, AwsServiceException, SdkClientException,
CloudWatchEventsException {
JsonOperationMetadata operationMetadata = JsonOperationMetadata.builder().hasStreamingSuccessResponse(false)
.isPayloadJson(true).build();
HttpResponseHandler responseHandler = protocolFactory.createResponseHandler(operationMetadata,
UntagResourceResponse::builder);
HttpResponseHandler errorResponseHandler = createErrorResponseHandler(protocolFactory,
operationMetadata);
return clientHandler.execute(new ClientExecutionParams()
.withOperationName("UntagResource").withResponseHandler(responseHandler)
.withErrorResponseHandler(errorResponseHandler).withInput(untagResourceRequest)
.withMarshaller(new UntagResourceRequestMarshaller(protocolFactory)));
}
private HttpResponseHandler createErrorResponseHandler(BaseAwsJsonProtocolFactory protocolFactory,
JsonOperationMetadata operationMetadata) {
return protocolFactory.createErrorResponseHandler(operationMetadata);
}
private > T init(T builder) {
return builder
.clientConfiguration(clientConfiguration)
.defaultServiceExceptionSupplier(CloudWatchEventsException::builder)
.protocol(AwsJsonProtocol.AWS_JSON)
.protocolVersion("1.1")
.registerModeledException(
ExceptionMetadata.builder().errorCode("ConcurrentModificationException")
.exceptionBuilderSupplier(ConcurrentModificationException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ResourceNotFoundException")
.exceptionBuilderSupplier(ResourceNotFoundException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("PolicyLengthExceededException")
.exceptionBuilderSupplier(PolicyLengthExceededException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("InvalidEventPatternException")
.exceptionBuilderSupplier(InvalidEventPatternException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("InternalException")
.exceptionBuilderSupplier(InternalException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("ManagedRuleException")
.exceptionBuilderSupplier(ManagedRuleException::builder).build())
.registerModeledException(
ExceptionMetadata.builder().errorCode("LimitExceededException")
.exceptionBuilderSupplier(LimitExceededException::builder).build());
}
@Override
public void close() {
clientHandler.close();
}
}