Light, fluffy, and always free - The AWS Local Emulator alternative
refactor(cloudformation): move the Events types into EventsCfnProvisioner (#3286)
Hector Ventura3218d2404eb5
diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.javaindex bf7d1c0c85..85710990bd 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/CloudFormationResourceProvisioner.java@@ -20,9 +20,7 @@ import io.github.hectorvent.floci.services.cloudformation.provisioners.CfnResourimport io.github.hectorvent.floci.services.cloudformation.provisioners.Ec2SecurityGroupRuleCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.UpdateCleanupResult;import io.github.hectorvent.floci.services.dynamodb.DynamoDbService;-import io.github.hectorvent.floci.services.eventbridge.EventBridgeService;import io.github.hectorvent.floci.services.eventbridge.model.BatchParameters;-import io.github.hectorvent.floci.services.eventbridge.model.EventBus;import io.github.hectorvent.floci.services.eventbridge.model.InputTransformer;import io.github.hectorvent.floci.services.eventbridge.model.RuleState;import io.github.hectorvent.floci.services.eventbridge.model.SqsParameters;@@ -126,13 +124,6 @@ public class CloudFormationResourceProvisioner {private static final String INLINE_CLEANUP_GROUP_TARGETS_ATTR = "__FlociInlineCleanupGroupTargets";private static final String SFN_NAME_MODE_ATTR = "FlociStepFunctionsNameMode";static final String SFN_UPDATE_SNAPSHOT_ATTR = "__FlociStepFunctionsUpdateSnapshot";- private static final String EVENT_BUS_CREATED_TIME_ATTR = "FlociEventBusCreatedTime";- private static final String EVENT_BUS_MANAGED_TAG_KEYS_ATTR = "FlociEventBusManagedTagKeys";- private static final String EVENT_BUS_MANAGED_POLICY_ATTR = "FlociEventBusManagedPolicy";- private static final Set<String> EVENT_BUS_SUPPORTED_PROPERTIES =- Set.of("Name", "Description", "Tags", "Policy");- private static final Pattern EVENT_BUS_TAG_PATTERN =- Pattern.compile("[\\p{L}\\p{N}\\p{Z}_.:/=+\\-@]*");private static final String NAME_MODE_EXPLICIT = "explicit";private static final String NAME_MODE_GENERATED = "generated";private static final int GENERATED_NAME_SUFFIX_LENGTH = 12;@@ -177,8 +168,6 @@ public class CloudFormationResourceProvisioner {"AWS::ApiGatewayV2::Authorizer","AWS::CloudFormation::CustomResource","AWS::EKS::Nodegroup",- "AWS::Events::EventBus",- "AWS::Events::Rule","AWS::IAM::ManagedPolicy","AWS::IAM::Policy","AWS::SecretsManager::SecretTargetAttachment",@@ -210,9 +199,6 @@ public class CloudFormationResourceProvisioner {"AWS::EC2::SecurityGroup","AWS::EKS::Cluster","AWS::EKS::Nodegroup",- "AWS::Events::EventBus",- "AWS::Events::EventBusPolicy",- "AWS::Events::Rule","AWS::IAM::AccessKey","AWS::IAM::InstanceProfile","AWS::IAM::ManagedPolicy",@@ -247,7 +233,6 @@ public class CloudFormationResourceProvisioner {private final LambdaService lambdaService;private final IamService iamService;private final SecretsManagerService secretsManagerService;- private final EventBridgeService eventBridgeService;private final ApiGatewayService apiGatewayService;private final ApiGatewayV2Service apiGatewayV2Service;private final LambdaLayerService lambdaLayerService;@@ -275,7 +260,6 @@ public class CloudFormationResourceProvisioner {LambdaService lambdaService, IamService iamService,SsmService ssmService, KmsService kmsService,SecretsManagerService secretsManagerService,- EventBridgeService eventBridgeService,ApiGatewayService apiGatewayService,ApiGatewayV2Service apiGatewayV2Service,EcrService ecrService,@@ -305,7 +289,6 @@ public class CloudFormationResourceProvisioner {this.lambdaService = lambdaService;this.iamService = iamService;this.secretsManagerService = secretsManagerService;- this.eventBridgeService = eventBridgeService;this.apiGatewayService = apiGatewayService;this.apiGatewayV2Service = apiGatewayV2Service;this.lambdaLayerService = lambdaLayerService;@@ -379,9 +362,6 @@ public class CloudFormationResourceProvisioner {case "AWS::SecretsManager::SecretTargetAttachment" ->provisionSecretTargetAttachment(resource, properties, engine, region, stackName);case "AWS::Route53::RecordSet" -> provisionRoute53RecordSet(resource, properties, engine);- case "AWS::Events::Rule" -> provisionEventBridgeRule(resource, properties, engine, region, stackName);- case "AWS::Events::EventBus" -> provisionEventBridgeEventBus(resource, properties, engine, region);- case "AWS::Events::EventBusPolicy" -> provisionEventBusPolicy(resource, properties, engine, region);case "AWS::ApiGateway::RestApi" -> provisionApiGatewayRestApi(resource, properties, engine, region, accountId, stackName);case "AWS::ApiGateway::Resource" -> provisionApiGatewayResource(resource, properties, engine, region);case "AWS::ApiGateway::Authorizer" -> provisionApiGatewayAuthorizer(resource, properties, engine, region);@@ -600,14 +580,6 @@ public class CloudFormationResourceProvisioner {}return;}- // Rule deletion needs the rule's event bus (stored as an attribute at provision time),- // which the type/physicalId delete path can't provide; a custom-bus rule looked up under- // the default bus would silently no-op and leave the rule (and its bus) live.- if ("AWS::Events::Rule".equals(resourceType)) {- deleteEventBridgeRuleSafe(resource.getPhysicalId(),- resource.getAttributes().get("EventBusName"), region);- return;- }// Authorizer deletion needs the api id (a stored attribute, not the physical id, which is// the authorizer id) — same shape as the Nodegroup case above. Without this, the generic// type/physicalId delete path has no case for this type at all and silently no-ops,@@ -635,10 +607,6 @@ public class CloudFormationResourceProvisioner {deleteManagedPolicy(resource);return;}- if ("AWS::Events::EventBus".equals(resourceType)) {- deleteEventBusSafe(resource, region);- return;- }throw new IllegalStateException("DELETE_NEEDS_STACK_RESOURCE lists " + resourceType+ " but no branch here deletes it — deleting it by physical id alone would "+ "silently no-op and leave the resource live.");@@ -673,9 +641,6 @@ public class CloudFormationResourceProvisioner {"SecretTargetAttachment deletion requires the StackResource metadata that records its managed fields.",400);// No bus context on the type/physicalId path (e.g. CREATE-rollback); targets the default bus.- case "AWS::Events::Rule" -> deleteEventBridgeRuleSafe(physicalId, null, region);- case "AWS::Events::EventBus" -> deleteEventBusSafe(physicalId, region);- case "AWS::Events::EventBusPolicy" -> removeEventBusPolicySafe(physicalId, region);case "AWS::ApiGateway::RestApi" -> apiGatewayService.deleteRestApi(region, physicalId);case "AWS::ApiGatewayV2::Api" -> apiGatewayV2Service.deleteApi(region, physicalId);case "AWS::StepFunctions::StateMachine" -> stepFunctionsService.deleteStateMachine(physicalId);@@ -3306,474 +3271,6 @@ public class CloudFormationResourceProvisioner {return password;}- // ── EventBridge ─────────────────────────────────────────────────────────-- private void provisionEventBridgeRule(StackResource r, JsonNode props, CloudFormationTemplateEngine engine,- String region, String stackName) {- String ruleName = resolveOptional(props, "Name", engine);- if (ruleName == null || ruleName.isBlank()) {- ruleName = generatePhysicalName(stackName, r.getLogicalId(), 64, false);- }-- String busName = resolveOptional(props, "EventBusName", engine);- String description = resolveOptional(props, "Description", engine);- String roleArn = resolveOptional(props, "RoleArn", engine);- String scheduleExpression = resolveOptional(props, "ScheduleExpression", engine);-- String eventPattern = null;- if (props != null && props.has("EventPattern") && !props.get("EventPattern").isNull()) {- JsonNode patternNode = engine.resolveNode(props.get("EventPattern"));- eventPattern = patternNode.toString();- }-- String stateStr = resolveOptional(props, "State", engine);- RuleState state = "DISABLED".equals(stateStr) ? RuleState.DISABLED : RuleState.ENABLED;-- var rule = eventBridgeService.putRule(ruleName, busName, eventPattern, scheduleExpression,- state, description, roleArn, Map.of(), region);- r.setPhysicalId(ruleName);- r.getAttributes().put("Arn", rule.getArn());- // A rule on a custom bus is keyed by that bus; remember it so the resource delete can target- // the right bus (the physical id is only the rule name, which resolves to the default bus).- if (busName != null && !busName.isBlank()) {- r.getAttributes().put("EventBusName", busName);- }-- // Provision inline targets- if (props != null && props.has("Targets")) {- List<Target> targets = new ArrayList<>();- for (JsonNode targetNode : props.get("Targets")) {- JsonNode resolved = engine.resolveNode(targetNode);- String targetId = resolved.path("Id").asText(null);- String targetArn = resolved.path("Arn").asText(null);- String input = resolved.path("Input").asText(null);- String inputPath = resolved.path("InputPath").asText(null);- if (targetId != null && targetArn != null) {- Target target = new Target(targetId, targetArn, input, inputPath);- target.setInputTransformer(InputTransformer.fromJson(resolved.path("InputTransformer")));- JsonNode sqsParamsNode = resolved.path("SqsParameters");- if (!sqsParamsNode.isMissingNode() && sqsParamsNode.isObject()) {- String messageGroupId = sqsParamsNode.path("MessageGroupId").asText(null);- if (messageGroupId != null) {- SqsParameters sqsParameters = new SqsParameters();- sqsParameters.setMessageGroupId(messageGroupId);- target.setSqsParameters(sqsParameters);- }- }- JsonNode batchParamsNode = resolved.path("BatchParameters");- if (!batchParamsNode.isMissingNode() && batchParamsNode.isObject()) {- JsonNode arrayProperties = batchParamsNode.path("ArrayProperties");- BatchParameters batchParameters = new BatchParameters();- batchParameters.setJobDefinition(batchParamsNode.path("JobDefinition").asText(null));- batchParameters.setJobName(batchParamsNode.path("JobName").asText(null));- if (arrayProperties.isObject()) {- batchParameters.setArrayProperties(jsonObjectToMap(arrayProperties));- }- if (batchParamsNode.has("RetryStrategy")) {- batchParameters.setRetryStrategy(batchParamsNode.get("RetryStrategy"));- }- target.setBatchParameters(batchParameters);- }- targets.add(target);- }- }- if (!targets.isEmpty()) {- eventBridgeService.putTargets(ruleName, busName, targets, region);- }- }- }-- /**- * Provisions an {@code AWS::Events::EventBus} (a custom EventBridge event bus). Without this the- * resource would fall through to the generic stub, which assigns a physical id but never registers- * the bus with the EventBridge service — so any {@code AWS::Events::Rule} (or PutEvents) targeting- * the bus fails "EventBus not found". Per the AWS spec, {@code Ref} returns the bus <em>name</em>- * (not the ARN), so the physical id is the name; {@code Fn::GetAtt "Arn"} exposes the ARN.- */- private void provisionEventBridgeEventBus(StackResource r, JsonNode props,- CloudFormationTemplateEngine engine, String region) {- validateEventBusProperties(props);- String existingBusName = r.getPhysicalId();- String busName = resolveOptional(props, "Name", engine);- validateEventBusName(busName);- if (existingBusName != null && !existingBusName.equals(busName)) {- throw new AwsException("ValidationError",- "Updating EventBus Name requires resource replacement, which is not supported.", 400);- }- String description = resolveOptional(props, "Description", engine);- if (description != null && description.length() > 512) {- throw new AwsException("ValidationError",- "AWS::Events::EventBus Description must not exceed 512 characters.", 400);- }- Map<String, String> tags = parseEventBusTags(- props != null ? props.get("Tags") : null, engine);- JsonNode policy = resolveEventBusPolicy(props, engine);-- EventBus bus;- boolean createdBus = false;- try {- bus = eventBridgeService.createEventBus(busName, description, tags, region);- createdBus = true;- r.getAttributes().put(CfnRollback.ROLLBACK_OWNED_ATTR, "true");- } catch (AwsException e) {- boolean stackAlreadyOwnsBus = existingBusName != null && existingBusName.equals(busName);- if (!stackAlreadyOwnsBus || !"ResourceAlreadyExistsException".equals(e.getErrorCode())) {- throw e;- }- bus = eventBridgeService.describeEventBus(busName, region);- // A missing created-time means ownership was never tracked, not that it changed: stacks- // provisioned before this attribute existed are restored without it. Refusing there would- // wedge every later UpdateStack, including no-op ones. Only a recorded time that actually- // disagrees means the bus was recreated out of band and belongs to its new owner.- String existingCreatedTime = r.getAttributes().get(EVENT_BUS_CREATED_TIME_ATTR);- String actualCreatedTime = eventBusCreatedTime(bus);- if (existingCreatedTime != null && !existingCreatedTime.equals(actualCreatedTime)) {- r.getAttributes().remove(CfnRollback.ROLLBACK_OWNED_ATTR);- throw e;- }- validateEventBusMutablePropertiesUnchanged(r, bus, description, tags, policy);- }-- // Record identity before applying the policy: rollbackCreatedResources skips any resource- // whose physicalId is still null, so a putPermission failure after the bus exists would- // otherwise orphan it with no way for rollback to find it.- r.setPhysicalId(busName); // Ref → EventBus name (AWS-faithful)- r.getAttributes().put("Arn", bus.getArn());- r.getAttributes().put("Name", busName);- r.getAttributes().put(EVENT_BUS_CREATED_TIME_ATTR, eventBusCreatedTime(bus));- recordEventBusManagedTagKeys(r, tags.keySet());- recordEventBusManagedPolicy(r, policy);-- // Apply an optional inline resource policy only during creation. Updating it is rejected by- // validateEventBusMutablePropertiesUnchanged until stack updates can roll back live resource- // mutations transactionally.- if (createdBus && !policy.isNull()) {- eventBridgeService.putPermission(busName, null, null, null, null, policy.toString(), region);- }- }-- private void validateEventBusProperties(JsonNode props) {- if (props == null || props.isNull()) {- return;- }- if (!props.isObject()) {- throw new AwsException("ValidationError",- "AWS::Events::EventBus Properties must be an object.", 400);- }- List<String> unsupported = new ArrayList<>();- props.fieldNames().forEachRemaining(name -> {- if (!EVENT_BUS_SUPPORTED_PROPERTIES.contains(name)) {- unsupported.add(name);- }- });- if (!unsupported.isEmpty()) {- Collections.sort(unsupported);- throw new AwsException("ValidationError",- "Unsupported AWS::Events::EventBus properties: "- + String.join(", ", unsupported), 400);- }- }-- private void validateEventBusName(String busName) {- if (busName == null || busName.isBlank()) {- throw new AwsException("ValidationError",- "Name is required for AWS::Events::EventBus.", 400);- }- if (busName.length() > 256- || !busName.matches("[.\\-_A-Za-z0-9]+")- || "default".equals(busName)) {- throw new AwsException("ValidationError",- "Invalid custom event bus Name: " + busName, 400);- }- }-- private Map<String, String> parseEventBusTags(- JsonNode tagsNode, CloudFormationTemplateEngine engine) {- if (tagsNode == null || tagsNode.isNull()) {- return Map.of();- }- JsonNode resolvedTags = engine.resolveNode(tagsNode);- if (!resolvedTags.isArray()) {- throw new AwsException("ValidationError",- "AWS::Events::EventBus Tags must be an array.", 400);- }- if (resolvedTags.size() > 50) {- throw new AwsException("ValidationError",- "AWS::Events::EventBus supports at most 50 tags.", 400);- }- Map<String, String> tags = new LinkedHashMap<>();- for (JsonNode entry : resolvedTags) {- if (!entry.isObject()) {- throw new AwsException("ValidationError",- "Each AWS::Events::EventBus tag must be an object.", 400);- }- String key = entry.path("Key").asText(null);- String value = entry.path("Value").asText(null);- if (key == null || key.isEmpty() || key.length() > 128) {- throw new AwsException("ValidationError",- "Event bus tag Key must contain 1 to 128 characters.", 400);- }- if (key.regionMatches(true, 0, "aws:", 0, 4)) {- throw new AwsException("ValidationError",- "Event bus tag Key must not use the reserved aws: prefix.", 400);- }- if (!EVENT_BUS_TAG_PATTERN.matcher(key).matches()) {- throw new AwsException("ValidationError",- "Event bus tag Key contains unsupported characters.", 400);- }- if (value == null || value.length() > 256) {- throw new AwsException("ValidationError",- "Event bus tag Value must contain at most 256 characters.", 400);- }- if (!EVENT_BUS_TAG_PATTERN.matcher(value).matches()) {- throw new AwsException("ValidationError",- "Event bus tag Value contains unsupported characters.", 400);- }- if (tags.putIfAbsent(key, value) != null) {- throw new AwsException("ValidationError",- "Duplicate event bus tag Key: " + key, 400);- }- }- return tags;- }-- private void validateEventBusMutablePropertiesUnchanged(- StackResource resource, EventBus bus, String requestedDescription,- Map<String, String> requestedTags, JsonNode requestedPolicy) {- if (!Objects.equals(bus.getDescription(), requestedDescription)) {- throw unsupportedEventBusMutableUpdate();- }-- // Stacks persisted by the older EventBus provisioner have no managed-key metadata. There- // is no reliable way to distinguish their CloudFormation tags from tags added out of band,- // so allow this one-time adoption and start tracking the requested keys afterwards.- if (resource.getAttributes().containsKey(EVENT_BUS_MANAGED_TAG_KEYS_ATTR)) {- Map<String, String> currentManagedTags = new LinkedHashMap<>();- for (String key : eventBusManagedTagKeys(resource)) {- if (bus.getTags().containsKey(key)) {- currentManagedTags.put(key, bus.getTags().get(key));- }- }- if (!currentManagedTags.equals(requestedTags)) {- throw unsupportedEventBusMutableUpdate();- }- }-- String managedPolicy = resource.getAttributes().get(EVENT_BUS_MANAGED_POLICY_ATTR);- JsonNode policyToCompare = managedPolicy != null- ? parseEventBusPolicy(managedPolicy, "stored CloudFormation metadata")- : parseEventBusPolicy(bus.getPolicy(), "the existing event bus");- if (managedPolicy != null || !requestedPolicy.isNull()) {- if (!policyToCompare.equals(requestedPolicy)) {- throw unsupportedEventBusMutableUpdate();- }- }- }-- private JsonNode resolveEventBusPolicy(JsonNode props, CloudFormationTemplateEngine engine) {- if (props == null || !props.has("Policy") || props.get("Policy").isNull()) {- return JsonNodeFactory.instance.nullNode();- }- return engine.resolveNode(props.get("Policy"));- }-- private JsonNode parseEventBusPolicy(String policy, String source) {- if (policy == null) {- return JsonNodeFactory.instance.nullNode();- }- try {- JsonNode parsed = objectMapper.readTree(policy);- return parsed != null ? parsed : JsonNodeFactory.instance.nullNode();- } catch (Exception e) {- throw new AwsException("InternalFailure",- "Invalid EventBus policy in " + source + ": " + e.getMessage(), 500);- }- }-- private void recordEventBusManagedPolicy(StackResource resource, JsonNode policy) {- try {- resource.getAttributes().put(EVENT_BUS_MANAGED_POLICY_ATTR,- objectMapper.writeValueAsString(policy));- } catch (Exception e) {- throw new AwsException("InternalFailure",- "Failed to store EventBus managed-policy metadata: " + e.getMessage(), 500);- }- }-- private AwsException unsupportedEventBusMutableUpdate() {- return new AwsException("ValidationError",- "Updating AWS::Events::EventBus Description, Tags, or Policy is not supported "- + "until transactional rollback is available.", 400);- }-- private Set<String> eventBusManagedTagKeys(StackResource resource) {- String value = resource.getAttributes().get(EVENT_BUS_MANAGED_TAG_KEYS_ATTR);- if (value == null || value.isBlank()) {- return Set.of();- }- try {- JsonNode keys = objectMapper.readTree(value);- if (!keys.isArray()) {- throw new IllegalArgumentException("managed tag keys are not an array");- }- Set<String> result = new HashSet<>();- keys.forEach(key -> result.add(key.asText()));- return result;- } catch (Exception e) {- throw new AwsException("InternalFailure",- "Invalid stored EventBus managed-tag metadata: " + e.getMessage(), 500);- }- }-- private void recordEventBusManagedTagKeys(StackResource resource, Set<String> keys) {- try {- resource.getAttributes().put(- EVENT_BUS_MANAGED_TAG_KEYS_ATTR,- objectMapper.writeValueAsString(new TreeSet<>(keys)));- } catch (Exception e) {- throw new AwsException("InternalFailure",- "Failed to store EventBus managed-tag metadata: " + e.getMessage(), 500);- }- }-- private String eventBusCreatedTime(EventBus bus) {- return bus.getCreatedTime() != null ? bus.getCreatedTime().toString() : "";- }-- private void deleteEventBridgeRuleSafe(String ruleName, String busName, String region) {- try {- // Remove all targets before deleting the rule (busName scopes the lookup to the rule's bus).- var targets = eventBridgeService.listTargetsByRule(ruleName, busName, region);- if (!targets.isEmpty()) {- List<String> targetIds = targets.stream().map(Target::getId).toList();- eventBridgeService.removeTargets(ruleName, busName, targetIds, region);- }- eventBridgeService.deleteRule(ruleName, busName, region);- } catch (AwsException e) {- // An already-deleted rule is the one failure that genuinely means "done". Anything else- // is a real error worth surfacing rather than hiding behind a debug line.- if (!"ResourceNotFoundException".equals(e.getErrorCode())) {- throw e;- }- LOG.debugv("EventBridge rule already gone, treating as deleted: {0}", ruleName);- } catch (Exception e) {- throw new AwsException("InternalFailure",- "Could not delete EventBridge rule " + ruleName + ": " + e.getMessage(), 500);- }- }-- private void deleteEventBusSafe(String busName, String region) {- try {- eventBridgeService.deleteEventBus(busName, region);- } catch (AwsException e) {- if (!"ResourceNotFoundException".equals(e.getErrorCode())) {- throw e;- }- LOG.debugv("Event bus already gone, treating as deleted: {0}", busName);- }- }-- private void deleteEventBusSafe(StackResource resource, String region) {- String busName = resource.getPhysicalId();- EventBus bus;- try {- bus = eventBridgeService.describeEventBus(busName, region);- } catch (AwsException e) {- if ("ResourceNotFoundException".equals(e.getErrorCode())) {- LOG.debugv("Event bus already gone, treating as deleted: {0}", busName);- return;- }- throw e;- }-- // A missing attribute means ownership was never tracked, not that it changed: stacks- // provisioned before this attribute existed are restored from cloudformation-stacks.json- // without it. Refusing there would leave every such stack permanently in DELETE_FAILED, so- // fall back to the pre-tracking behaviour of deleting what the stack recorded it created.- String expectedCreatedTime = resource.getAttributes().get(EVENT_BUS_CREATED_TIME_ATTR);- if (expectedCreatedTime != null && !expectedCreatedTime.equals(eventBusCreatedTime(bus))) {- throw new AwsException("ValidationError",- "EventBus ownership changed; refusing to delete: " + busName, 400);- }- deleteEventBusSafe(busName, region);- }--- private void provisionEventBusPolicy(StackResource r, JsonNode props, CloudFormationTemplateEngine engine,- String region) {- String busName = resolveOrDefault(props, "EventBusName", engine, "default");- String statementId = resolveOptional(props, "StatementId", engine);- if (statementId == null || statementId.isBlank()) {- throw new AwsException("ValidationException", "EventBusPolicy StatementId is required.", 400);- }-- if (props != null && props.has("Statement") && props.get("Statement").isObject()) {- // Statement form: merge the full statement into the bus policy, keyed by Sid,- // so multiple EventBusPolicy resources on the same bus coexist.- try {- ObjectNode statement = (ObjectNode) engine.resolveNode(props.get("Statement")).deepCopy();- statement.put("Sid", statementId);-- EventBus bus = eventBridgeService.describeEventBus(busName, region);- ObjectNode policy;- String current = bus.getPolicy();- if (current != null && !current.isBlank()) {- policy = (ObjectNode) objectMapper.readTree(current);- } else {- policy = objectMapper.createObjectNode();- policy.put("Version", "2012-10-17");- policy.putArray("Statement");- }- ArrayNode statements = policy.withArray("Statement");- for (int i = 0; i < statements.size(); i++) {- if (statementId.equals(statements.get(i).path("Sid").asText(null))) {- statements.remove(i);- break;- }- }- statements.add(statement);- eventBridgeService.putPermission(busName, null, null, statementId, null,- objectMapper.writeValueAsString(policy), region);- } catch (AwsException e) {- throw e;- } catch (Exception e) {- throw new AwsException("ValidationException",- "Invalid EventBusPolicy Statement: " + e.getMessage(), 400);- }- r.setPhysicalId(busName + "|" + statementId);- return;- }-- // Individual form: Action + Principal (+ optional Condition {Type, Key, Value}).- String action = resolveOptional(props, "Action", engine);- String principal = resolveOptional(props, "Principal", engine);- String conditionJson = null;- if (props != null && props.has("Condition") && !props.get("Condition").isNull()) {- JsonNode c = engine.resolveNode(props.get("Condition"));- String type = c.path("Type").asText(null);- String key = c.path("Key").asText(null);- String value = c.path("Value").asText(null);- if (type != null && key != null && value != null) {- ObjectNode condition = objectMapper.createObjectNode();- condition.set(type, objectMapper.createObjectNode().put(key, value));- conditionJson = condition.toString();- }- }- eventBridgeService.putPermission(busName, action, principal, statementId, conditionJson, null, region);-- r.setPhysicalId(busName + "|" + statementId);- }-- private void removeEventBusPolicySafe(String physicalId, String region) {- try {- int sep = physicalId.lastIndexOf('|');- String busName = sep >= 0 ? physicalId.substring(0, sep) : "default";- String statementId = sep >= 0 ? physicalId.substring(sep + 1) : physicalId;- eventBridgeService.removePermission(busName, statementId, false, region);- } catch (Exception e) {- LOG.debugv("Could not remove event bus policy {0}: {1}", physicalId, e.getMessage());- }- }// ── Batch ────────────────────────────────────────────────────────────────diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnRollback.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnRollback.javaindex 45b8ea29a7..78d05a9078 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnRollback.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/CfnRollback.java@@ -44,6 +44,15 @@ public final class CfnRollback {*/public static final String PIPE_UPDATE_SNAPSHOT_ATTR = "__FlociPipeUpdateSnapshot";+ /**+ * Holds the targets an EventBridge rule carried before the update in flight reconciled them,+ * with the rule name, bus and region needed to address them again, so a failed stack update can+ * put them back. Written by {@code EventsCfnProvisioner} before its first target call and spent+ * by its {@code rollbackUpdate}. The rule name alone does not address a target: a rule on a+ * custom bus is keyed by that bus, and the rollback hook is handed the stack resource alone.+ */+ public static final String RULE_TARGETS_SNAPSHOT_ATTR = "__FlociRuleTargetsSnapshot";+/*** Holds the settings an event invoke configuration carried before an in-place update changed* them, in the request shape a put takes, so a failed stack update can put them back. Writtendiff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EventsCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EventsCfnProvisioner.javanew file mode 100644index 0000000000..558079a3e6--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EventsCfnProvisioner.java@@ -0,0 +1,766 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.core.JsonProcessingException;+import com.fasterxml.jackson.core.type.TypeReference;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.JsonNodeFactory;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.eventbridge.EventBridgeService;+import io.github.hectorvent.floci.services.eventbridge.model.BatchParameters;+import io.github.hectorvent.floci.services.eventbridge.model.EventBus;+import io.github.hectorvent.floci.services.eventbridge.model.InputTransformer;+import io.github.hectorvent.floci.services.eventbridge.model.RuleState;+import io.github.hectorvent.floci.services.eventbridge.model.SqsParameters;+import io.github.hectorvent.floci.services.eventbridge.model.Target;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.util.ArrayList;+import java.util.Collections;+import java.util.HashSet;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.Objects;+import java.util.Set;+import java.util.stream.Collectors;+import java.util.TreeSet;+import java.util.regex.Pattern;++/**+ * CloudFormation provisioning for EventBridge: {@code AWS::Events::Rule},+ * {@code AWS::Events::EventBus} and {@code AWS::Events::EventBusPolicy}. Extracted from+ * {@code CloudFormationResourceProvisioner}.+ *+ * <p>Two of these types need the resource's stored attributes to delete, not just the physical+ * id, so they are served by the {@link #delete(StackResource, String)} override rather than the+ * id-only form: a rule remembers the custom bus it lives on, and an event bus remembers the+ * creation time that proves the stack still owns it.+ */+@ApplicationScoped+public class EventsCfnProvisioner implements CfnResourceProvisioner {++ private static final Logger LOG = Logger.getLogger(EventsCfnProvisioner.class);+ private static final ObjectMapper MAPPER = new ObjectMapper();++ private static final String EVENT_BUS_CREATED_TIME_ATTR = "FlociEventBusCreatedTime";+ private static final String EVENT_BUS_MANAGED_TAG_KEYS_ATTR = "FlociEventBusManagedTagKeys";+ private static final String EVENT_BUS_MANAGED_POLICY_ATTR = "FlociEventBusManagedPolicy";+ private static final Set<String> EVENT_BUS_SUPPORTED_PROPERTIES =+ Set.of("Name", "Description", "Tags", "Policy");+ private static final Pattern EVENT_BUS_TAG_PATTERN =+ Pattern.compile("[\\p{L}\\p{N}\\p{Z}_.:/=+\\-@]*");+ private static final Pattern STATEMENT_ID_PATTERN = Pattern.compile("[a-zA-Z0-9\\-_]+");+ private static final int STATEMENT_ID_MAX_LENGTH = 64;++ private final EventBridgeService eventBridgeService;++ @Inject+ public EventsCfnProvisioner(EventBridgeService eventBridgeService) {+ this.eventBridgeService = eventBridgeService;+ }++ @Override+ public Set<String> resourceTypes() {+ return Set.of("AWS::Events::Rule", "AWS::Events::EventBus", "AWS::Events::EventBusPolicy");+ }++ @Override+ public void provision(StackResource r, JsonNode props, ProvisionContext ctx) {+ switch (r.getResourceType()) {+ case "AWS::Events::Rule" -> provisionRule(r, props, ctx);+ case "AWS::Events::EventBus" -> provisionEventBus(r, props, ctx);+ case "AWS::Events::EventBusPolicy" -> provisionEventBusPolicy(r, props, ctx);+ default -> throw new IllegalStateException(+ "EventsCfnProvisioner cannot handle " + r.getResourceType());+ }+ }++ /**+ * A rule and an event bus both need attributes the physical id cannot carry: the rule's custom+ * bus, and the bus's recorded creation time. Deleting either by id alone would silently target+ * the default bus or skip the ownership check.+ */+ @Override+ public void delete(StackResource resource, String region) {+ switch (resource.getResourceType()) {+ case "AWS::Events::Rule" -> deleteEventBridgeRuleSafe(resource.getPhysicalId(),+ resource.getAttributes() != null ? resource.getAttributes().get("EventBusName") : null,+ region);+ case "AWS::Events::EventBus" -> deleteEventBusSafe(resource, region);+ default -> delete(resource.getResourceType(), resource.getPhysicalId(), region);+ }+ }++ @Override+ public void delete(String resourceType, String physicalId, String region) {+ if (physicalId == null || physicalId.isBlank()) {+ return;+ }+ switch (resourceType) {+ case "AWS::Events::Rule" -> deleteEventBridgeRuleSafe(physicalId, null, region);+ case "AWS::Events::EventBus" -> deleteEventBusSafe(physicalId, region);+ case "AWS::Events::EventBusPolicy" -> removeEventBusPolicySafe(physicalId, region);+ default -> {+ // no other type reaches this provisioner+ }+ }+ }++ private void provisionRule(StackResource r, JsonNode props, ProvisionContext ctx) {+ // A snapshot describes the update in flight. The one an earlier update left behind goes+ // before this run touches a target, so a rollback never puts back a target the rule stopped+ // carrying two updates ago.+ r.getAttributes().remove(CfnRollback.RULE_TARGETS_SNAPSHOT_ATTR);+ // Name is createOnly and the physical id is the rule name, so ctx.stablePhysicalName+ // applies directly: without it an unnamed rule was given a fresh random name on every+ // UpdateStack, creating a second rule and leaving the first behind with its targets.+ String ruleName = ctx.stablePhysicalName(+ ctx.resolveOptional(props, "Name"), r.getLogicalId(), 64, false);++ String busName = ctx.resolveOptional(props, "EventBusName");+ String description = ctx.resolveOptional(props, "Description");+ String roleArn = ctx.resolveOptional(props, "RoleArn");+ String scheduleExpression = ctx.resolveOptional(props, "ScheduleExpression");++ String eventPattern = null;+ if (props != null && props.has("EventPattern") && !props.get("EventPattern").isNull()) {+ JsonNode patternNode = ctx.engine().resolveNode(props.get("EventPattern"));+ eventPattern = patternNode.toString();+ }++ String stateStr = ctx.resolveOptional(props, "State");+ RuleState state = "DISABLED".equals(stateStr) ? RuleState.DISABLED : RuleState.ENABLED;++ var rule = eventBridgeService.putRule(ruleName, busName, eventPattern, scheduleExpression,+ state, description, roleArn, Map.of(), ctx.region());+ r.setPhysicalId(ruleName);+ r.getAttributes().put("Arn", rule.getArn());+ // A rule on a custom bus is keyed by that bus; remember it so the resource delete can target+ // the right bus (the physical id is only the rule name, which resolves to the default bus).+ if (busName != null && !busName.isBlank()) {+ r.getAttributes().put("EventBusName", busName);+ }++ // Provision inline targets+ List<Target> targets = new ArrayList<>();+ if (props != null && props.has("Targets") && props.get("Targets").isArray()) {+ for (JsonNode targetNode : props.get("Targets")) {+ JsonNode resolved = ctx.engine().resolveNode(targetNode);+ String targetId = resolved.path("Id").asText(null);+ String targetArn = resolved.path("Arn").asText(null);+ String input = resolved.path("Input").asText(null);+ String inputPath = resolved.path("InputPath").asText(null);+ if (targetId != null && targetArn != null) {+ Target target = new Target(targetId, targetArn, input, inputPath);+ target.setInputTransformer(InputTransformer.fromJson(resolved.path("InputTransformer")));+ JsonNode sqsParamsNode = resolved.path("SqsParameters");+ if (!sqsParamsNode.isMissingNode() && sqsParamsNode.isObject()) {+ String messageGroupId = sqsParamsNode.path("MessageGroupId").asText(null);+ if (messageGroupId != null) {+ SqsParameters sqsParameters = new SqsParameters();+ sqsParameters.setMessageGroupId(messageGroupId);+ target.setSqsParameters(sqsParameters);+ }+ }+ JsonNode batchParamsNode = resolved.path("BatchParameters");+ if (!batchParamsNode.isMissingNode() && batchParamsNode.isObject()) {+ JsonNode arrayProperties = batchParamsNode.path("ArrayProperties");+ BatchParameters batchParameters = new BatchParameters();+ batchParameters.setJobDefinition(batchParamsNode.path("JobDefinition").asText(null));+ batchParameters.setJobName(batchParamsNode.path("JobName").asText(null));+ if (arrayProperties.isObject()) {+ batchParameters.setArrayProperties(jsonObjectToMap(arrayProperties));+ }+ if (batchParamsNode.has("RetryStrategy")) {+ batchParameters.setRetryStrategy(batchParamsNode.get("RetryStrategy"));+ }+ target.setBatchParameters(batchParameters);+ }+ targets.add(target);+ }+ }+ }+ if (ctx.isUpdate()) {+ snapshotTargetsBeforeUpdate(r, ruleName, busName, ctx.region());+ }+ try {+ if (!targets.isEmpty()) {+ eventBridgeService.putTargets(ruleName, busName, targets, ctx.region());+ }+ removeStaleTargets(ruleName, busName, targets, ctx.region());+ } catch (RuntimeException updateFailure) {+ restoreTargetsAfterFailedUpdate(r, updateFailure);+ throw updateFailure;+ }+ }++ /**+ * Records the targets the rule carries before this update reconciles them, so they can be put+ * back when the stack update fails: by {@link #restoreTargetsAfterFailedUpdate} when this+ * rule's own reconciliation is what failed, and by {@link #rollbackUpdate} when a later+ * resource is. Only taken on an update, because a create has nothing to restore to.+ *+ * <p>The rule name, its bus and the region travel with the targets because the rollback hook is+ * handed the stack resource alone, and those three are how targets are addressed.+ */+ private void snapshotTargetsBeforeUpdate(StackResource r, String ruleName, String busName, String region) {+ ObjectNode snapshot = MAPPER.createObjectNode();+ snapshot.put("ruleName", ruleName);+ snapshot.put("busName", busName);+ snapshot.put("region", region);+ snapshot.set("targets", MAPPER.valueToTree(+ eventBridgeService.listTargetsByRule(ruleName, busName, region)));+ r.getAttributes().put(CfnRollback.RULE_TARGETS_SNAPSHOT_ATTR, snapshot.toString());+ }++ /**+ * Puts the rule's targets back from the snapshot this update took, while the failure that+ * interrupted the reconciliation is on its way out of the provisioner. The snapshot is spent+ * here, so the rollback hook finds nothing left to act on for a rule already restored.+ *+ * <p>A restore that fails itself leaves the rule delivering to a set of targets nobody+ * recorded. Its reason goes on the resource under+ * {@link CfnRollback#UPDATE_ROLLBACK_FAILURE_ATTR}, which is what makes the stack report+ * UPDATE_ROLLBACK_FAILED naming this resource instead of a clean rollback, and it is attached+ * to the update failure as suppressed so neither is lost. The restore repeats the calls the+ * update just made, so it can come back carrying the very exception that interrupted the+ * update; suppressing a throwable under itself is rejected by the JDK, and that one is already+ * the failure being reported.+ */+ private void restoreTargetsAfterFailedUpdate(StackResource r, RuntimeException updateFailure) {+ String rawSnapshot = r.getAttributes().get(CfnRollback.RULE_TARGETS_SNAPSHOT_ATTR);+ if (rawSnapshot == null) {+ return;+ }+ try {+ restoreSnapshottedTargets(r, MAPPER.readTree(rawSnapshot));+ } catch (RuntimeException | JsonProcessingException restoreFailure) {+ if (restoreFailure != updateFailure) {+ updateFailure.addSuppressed(restoreFailure);+ }+ String reason = restoreFailure.getMessage() != null+ ? restoreFailure.getMessage()+ : restoreFailure.getClass().getSimpleName();+ LOG.errorv("Could not restore the targets of rule {0} after a failed update: {1}",+ r.getPhysicalId(), reason);+ r.getAttributes().put(CfnRollback.UPDATE_ROLLBACK_FAILURE_ATTR, reason);+ }+ }++ /**+ * Puts the rule's targets back to what the snapshot holds and spends it. Exact rather than+ * additive: a target the failed update added is removed, and every snapshotted target is put+ * again, so one the update modified goes back to the configuration it was found with.+ *+ * <p>This is the hook for an update a <em>later</em> resource failed: this rule's own+ * reconciliation committed, so its snapshot is still unspent. When the rule's own+ * reconciliation is what failed, {@link #restoreTargetsAfterFailedUpdate} has already restored+ * it inside {@code provision} and spent the snapshot there, and a rule this run never touched+ * carries no snapshot at all, which is the false this returns so the stack keeps reporting that+ * rollback is not implemented rather than silently clearing its targets.+ */+ @Override+ public boolean rollbackUpdate(StackResource resource) {+ String rawSnapshot = resource.getAttributes().get(CfnRollback.RULE_TARGETS_SNAPSHOT_ATTR);+ if (rawSnapshot == null) {+ return false;+ }+ try {+ restoreSnapshottedTargets(resource, MAPPER.readTree(rawSnapshot));+ } catch (JsonProcessingException unreadableSnapshot) {+ throw new IllegalStateException("Could not read the rule target snapshot for "+ + resource.getLogicalId(), unreadableSnapshot);+ }+ return true;+ }++ private void restoreSnapshottedTargets(StackResource resource, JsonNode snapshot) {+ String ruleName = snapshotText(snapshot, "ruleName");+ String busName = snapshotText(snapshot, "busName");+ String region = snapshot.get("region").asText();+ List<Target> restored = MAPPER.convertValue(+ snapshot.path("targets"), new TypeReference<List<Target>>() { });+ Set<String> restoredIds = restored.stream().map(Target::getId).collect(Collectors.toSet());+ List<String> added = eventBridgeService.listTargetsByRule(ruleName, busName, region).stream()+ .map(Target::getId)+ .filter(id -> !restoredIds.contains(id))+ .toList();+ if (!added.isEmpty()) {+ eventBridgeService.removeTargets(ruleName, busName, added, region);+ }+ if (!restored.isEmpty()) {+ eventBridgeService.putTargets(ruleName, busName, restored, region);+ }+ resource.getAttributes().remove(CfnRollback.RULE_TARGETS_SNAPSHOT_ATTR);+ }++ /** A snapshotted string, or null when the rule carried none. */+ private static String snapshotText(JsonNode snapshot, String property) {+ JsonNode value = snapshot.get(property);+ return value == null || value.isNull() ? null : value.asText();+ }++ /**+ * Drives the rule's targets to the template's desired state. PutTargets only upserts by id,+ * so a target dropped from the template stayed on the rule forever, still delivering events.+ * A template that declares no Targets at all means no targets, so the sweep runs either way.+ */+ private void removeStaleTargets(String ruleName, String busName, List<Target> desired, String region) {+ Set<String> desiredIds = desired.stream().map(Target::getId).collect(Collectors.toSet());+ List<String> stale = eventBridgeService.listTargetsByRule(ruleName, busName, region).stream()+ .map(Target::getId)+ .filter(id -> !desiredIds.contains(id))+ .toList();+ if (!stale.isEmpty()) {+ eventBridgeService.removeTargets(ruleName, busName, stale, region);+ }+ }++ /**+ * Provisions an {@code AWS::Events::EventBus} (a custom EventBridge event bus). Without this the+ * resource would fall through to the generic stub, which assigns a physical id but never registers+ * the bus with the EventBridge service, so any {@code AWS::Events::Rule} (or PutEvents) targeting+ * the bus fails "EventBus not found". Per the AWS spec, {@code Ref} returns the bus <em>name</em>+ * (not the ARN), so the physical id is the name; {@code Fn::GetAtt "Arn"} exposes the ARN.+ */+ private void provisionEventBus(StackResource r, JsonNode props, ProvisionContext ctx) {+ validateEventBusProperties(props);+ String existingBusName = ctx.isUpdate() ? ctx.priorPhysicalId() : null;+ String busName = ctx.resolveOptional(props, "Name");+ validateEventBusName(busName);+ if (existingBusName != null && !existingBusName.equals(busName)) {+ throw new AwsException("ValidationError",+ "Updating EventBus Name requires resource replacement, which is not supported.", 400);+ }+ String description = ctx.resolveOptional(props, "Description");+ if (description != null && description.length() > 512) {+ throw new AwsException("ValidationError",+ "AWS::Events::EventBus Description must not exceed 512 characters.", 400);+ }+ Map<String, String> tags = parseEventBusTags(props != null ? props.get("Tags") : null, ctx);+ JsonNode policy = resolveEventBusPolicy(props, ctx);++ EventBus bus;+ boolean createdBus = false;+ try {+ bus = eventBridgeService.createEventBus(busName, description, tags, ctx.region());+ createdBus = true;+ r.getAttributes().put(CfnRollback.ROLLBACK_OWNED_ATTR, "true");+ } catch (AwsException e) {+ boolean stackAlreadyOwnsBus = existingBusName != null && existingBusName.equals(busName);+ if (!stackAlreadyOwnsBus || !"ResourceAlreadyExistsException".equals(e.getErrorCode())) {+ throw e;+ }+ bus = eventBridgeService.describeEventBus(busName, ctx.region());+ // A missing created-time means ownership was never tracked, not that it changed: stacks+ // provisioned before this attribute existed are restored without it. Refusing there would+ // wedge every later UpdateStack, including no-op ones. Only a recorded time that actually+ // disagrees means the bus was recreated out of band and belongs to its new owner.+ String existingCreatedTime = r.getAttributes().get(EVENT_BUS_CREATED_TIME_ATTR);+ String actualCreatedTime = eventBusCreatedTime(bus);+ if (existingCreatedTime != null && !existingCreatedTime.equals(actualCreatedTime)) {+ r.getAttributes().remove(CfnRollback.ROLLBACK_OWNED_ATTR);+ throw e;+ }+ validateEventBusMutablePropertiesUnchanged(r, bus, description, tags, policy);+ }++ // Record identity before applying the policy: rollbackCreatedResources skips any resource+ // whose physicalId is still null, so a putPermission failure after the bus exists would+ // otherwise orphan it with no way for rollback to find it.+ r.setPhysicalId(busName); // Ref → EventBus name (AWS-faithful)+ r.getAttributes().put("Arn", bus.getArn());+ r.getAttributes().put("Name", busName);+ r.getAttributes().put(EVENT_BUS_CREATED_TIME_ATTR, eventBusCreatedTime(bus));+ recordEventBusManagedTagKeys(r, tags.keySet());+ recordEventBusManagedPolicy(r, policy);++ // Apply an optional inline resource policy only during creation. Updating it is rejected by+ // validateEventBusMutablePropertiesUnchanged until stack updates can roll back live resource+ // mutations transactionally.+ if (createdBus && !policy.isNull()) {+ eventBridgeService.putPermission(busName, null, null, null, null, policy.toString(), ctx.region());+ }+ }++ private void validateEventBusProperties(JsonNode props) {+ if (props == null || props.isNull()) {+ return;+ }+ if (!props.isObject()) {+ throw new AwsException("ValidationError",+ "AWS::Events::EventBus Properties must be an object.", 400);+ }+ List<String> unsupported = new ArrayList<>();+ props.fieldNames().forEachRemaining(name -> {+ if (!EVENT_BUS_SUPPORTED_PROPERTIES.contains(name)) {+ unsupported.add(name);+ }+ });+ if (!unsupported.isEmpty()) {+ Collections.sort(unsupported);+ throw new AwsException("ValidationError",+ "Unsupported AWS::Events::EventBus properties: "+ + String.join(", ", unsupported), 400);+ }+ }++ private void validateEventBusName(String busName) {+ if (busName == null || busName.isBlank()) {+ throw new AwsException("ValidationError",+ "Name is required for AWS::Events::EventBus.", 400);+ }+ if (busName.length() > 256+ || !busName.matches("[.\\-_A-Za-z0-9]+")+ || "default".equals(busName)) {+ throw new AwsException("ValidationError",+ "Invalid custom event bus Name: " + busName, 400);+ }+ }++ private Map<String, String> parseEventBusTags(JsonNode tagsNode, ProvisionContext ctx) {+ if (tagsNode == null || tagsNode.isNull()) {+ return Map.of();+ }+ JsonNode resolvedTags = ctx.engine().resolveNode(tagsNode);+ if (!resolvedTags.isArray()) {+ throw new AwsException("ValidationError",+ "AWS::Events::EventBus Tags must be an array.", 400);+ }+ if (resolvedTags.size() > 50) {+ throw new AwsException("ValidationError",+ "AWS::Events::EventBus supports at most 50 tags.", 400);+ }+ Map<String, String> tags = new LinkedHashMap<>();+ for (JsonNode entry : resolvedTags) {+ if (!entry.isObject()) {+ throw new AwsException("ValidationError",+ "Each AWS::Events::EventBus tag must be an object.", 400);+ }+ String key = entry.path("Key").asText(null);+ String value = entry.path("Value").asText(null);+ if (key == null || key.isEmpty() || key.length() > 128) {+ throw new AwsException("ValidationError",+ "Event bus tag Key must contain 1 to 128 characters.", 400);+ }+ if (key.regionMatches(true, 0, "aws:", 0, 4)) {+ throw new AwsException("ValidationError",+ "Event bus tag Key must not use the reserved aws: prefix.", 400);+ }+ if (!EVENT_BUS_TAG_PATTERN.matcher(key).matches()) {+ throw new AwsException("ValidationError",+ "Event bus tag Key contains unsupported characters.", 400);+ }+ if (value == null || value.length() > 256) {+ throw new AwsException("ValidationError",+ "Event bus tag Value must contain at most 256 characters.", 400);+ }+ if (!EVENT_BUS_TAG_PATTERN.matcher(value).matches()) {+ throw new AwsException("ValidationError",+ "Event bus tag Value contains unsupported characters.", 400);+ }+ if (tags.putIfAbsent(key, value) != null) {+ throw new AwsException("ValidationError",+ "Duplicate event bus tag Key: " + key, 400);+ }+ }+ return tags;+ }++ private void validateEventBusMutablePropertiesUnchanged(+ StackResource resource, EventBus bus, String requestedDescription,+ Map<String, String> requestedTags, JsonNode requestedPolicy) {+ if (!Objects.equals(bus.getDescription(), requestedDescription)) {+ throw unsupportedEventBusMutableUpdate();+ }++ // Stacks persisted by the older EventBus provisioner have no managed-key metadata. There+ // is no reliable way to distinguish their CloudFormation tags from tags added out of band,+ // so allow this one-time adoption and start tracking the requested keys afterwards.+ if (resource.getAttributes().containsKey(EVENT_BUS_MANAGED_TAG_KEYS_ATTR)) {+ Map<String, String> currentManagedTags = new LinkedHashMap<>();+ for (String key : eventBusManagedTagKeys(resource)) {+ if (bus.getTags().containsKey(key)) {+ currentManagedTags.put(key, bus.getTags().get(key));+ }+ }+ if (!currentManagedTags.equals(requestedTags)) {+ throw unsupportedEventBusMutableUpdate();+ }+ }++ String managedPolicy = resource.getAttributes().get(EVENT_BUS_MANAGED_POLICY_ATTR);+ JsonNode policyToCompare = managedPolicy != null+ ? parseEventBusPolicy(managedPolicy, "stored CloudFormation metadata")+ : parseEventBusPolicy(bus.getPolicy(), "the existing event bus");+ if (managedPolicy != null || !requestedPolicy.isNull()) {+ if (!policyToCompare.equals(requestedPolicy)) {+ throw unsupportedEventBusMutableUpdate();+ }+ }+ }++ private JsonNode resolveEventBusPolicy(JsonNode props, ProvisionContext ctx) {+ if (props == null || !props.has("Policy") || props.get("Policy").isNull()) {+ return JsonNodeFactory.instance.nullNode();+ }+ return ctx.engine().resolveNode(props.get("Policy"));+ }++ private JsonNode parseEventBusPolicy(String policy, String source) {+ if (policy == null) {+ return JsonNodeFactory.instance.nullNode();+ }+ try {+ JsonNode parsed = MAPPER.readTree(policy);+ return parsed != null ? parsed : JsonNodeFactory.instance.nullNode();+ } catch (Exception e) {+ throw new AwsException("InternalFailure",+ "Invalid EventBus policy in " + source + ": " + e.getMessage(), 500);+ }+ }++ private void recordEventBusManagedPolicy(StackResource resource, JsonNode policy) {+ try {+ resource.getAttributes().put(EVENT_BUS_MANAGED_POLICY_ATTR,+ MAPPER.writeValueAsString(policy));+ } catch (Exception e) {+ throw new AwsException("InternalFailure",+ "Failed to store EventBus managed-policy metadata: " + e.getMessage(), 500);+ }+ }++ private AwsException unsupportedEventBusMutableUpdate() {+ return new AwsException("ValidationError",+ "Updating AWS::Events::EventBus Description, Tags, or Policy is not supported "+ + "until transactional rollback is available.", 400);+ }++ private Set<String> eventBusManagedTagKeys(StackResource resource) {+ String value = resource.getAttributes().get(EVENT_BUS_MANAGED_TAG_KEYS_ATTR);+ if (value == null || value.isBlank()) {+ return Set.of();+ }+ try {+ JsonNode keys = MAPPER.readTree(value);+ if (!keys.isArray()) {+ throw new IllegalArgumentException("managed tag keys are not an array");+ }+ Set<String> result = new HashSet<>();+ keys.forEach(key -> result.add(key.asText()));+ return result;+ } catch (Exception e) {+ throw new AwsException("InternalFailure",+ "Invalid stored EventBus managed-tag metadata: " + e.getMessage(), 500);+ }+ }++ private void recordEventBusManagedTagKeys(StackResource resource, Set<String> keys) {+ try {+ resource.getAttributes().put(+ EVENT_BUS_MANAGED_TAG_KEYS_ATTR,+ MAPPER.writeValueAsString(new TreeSet<>(keys)));+ } catch (Exception e) {+ throw new AwsException("InternalFailure",+ "Failed to store EventBus managed-tag metadata: " + e.getMessage(), 500);+ }+ }++ private String eventBusCreatedTime(EventBus bus) {+ return bus.getCreatedTime() != null ? bus.getCreatedTime().toString() : "";+ }++ private void deleteEventBridgeRuleSafe(String ruleName, String busName, String region) {+ try {+ // Remove all targets before deleting the rule (busName scopes the lookup to the rule's bus).+ var targets = eventBridgeService.listTargetsByRule(ruleName, busName, region);+ if (!targets.isEmpty()) {+ List<String> targetIds = targets.stream().map(Target::getId).toList();+ eventBridgeService.removeTargets(ruleName, busName, targetIds, region);+ }+ eventBridgeService.deleteRule(ruleName, busName, region);+ } catch (AwsException e) {+ // An already-deleted rule is the one failure that genuinely means "done". Anything else+ // is a real error worth surfacing rather than hiding behind a debug line.+ if (!"ResourceNotFoundException".equals(e.getErrorCode())) {+ throw e;+ }+ LOG.debugv("EventBridge rule already gone, treating as deleted: {0}", ruleName);+ } catch (Exception e) {+ throw new AwsException("InternalFailure",+ "Could not delete EventBridge rule " + ruleName + ": " + e.getMessage(), 500);+ }+ }++ private void deleteEventBusSafe(String busName, String region) {+ try {+ eventBridgeService.deleteEventBus(busName, region);+ } catch (AwsException e) {+ if (!"ResourceNotFoundException".equals(e.getErrorCode())) {+ throw e;+ }+ LOG.debugv("Event bus already gone, treating as deleted: {0}", busName);+ }+ }++ private void deleteEventBusSafe(StackResource resource, String region) {+ String busName = resource.getPhysicalId();+ EventBus bus;+ try {+ bus = eventBridgeService.describeEventBus(busName, region);+ } catch (AwsException e) {+ if ("ResourceNotFoundException".equals(e.getErrorCode())) {+ LOG.debugv("Event bus already gone, treating as deleted: {0}", busName);+ return;+ }+ throw e;+ }++ // A missing attribute means ownership was never tracked, not that it changed: stacks+ // provisioned before this attribute existed are restored from cloudformation-stacks.json+ // without it. Refusing there would leave every such stack permanently in DELETE_FAILED, so+ // fall back to the pre-tracking behaviour of deleting what the stack recorded it created.+ String expectedCreatedTime = resource.getAttributes().get(EVENT_BUS_CREATED_TIME_ATTR);+ if (expectedCreatedTime != null && !expectedCreatedTime.equals(eventBusCreatedTime(bus))) {+ throw new AwsException("ValidationError",+ "EventBus ownership changed; refusing to delete: " + busName, 400);+ }+ deleteEventBusSafe(busName, region);+ }+++ private void provisionEventBusPolicy(StackResource r, JsonNode props, ProvisionContext ctx) {+ String busName = resolveOrDefault(props, "EventBusName", ctx, "default");+ String statementId = ctx.resolveOptional(props, "StatementId");+ if (statementId == null || statementId.isBlank()) {+ throw new AwsException("ValidationException", "EventBusPolicy StatementId is required.", 400);+ }+ validateStatementId(statementId);++ if (props != null && props.has("Statement") && props.get("Statement").isObject()) {+ // Statement form: merge the full statement into the bus policy, keyed by Sid,+ // so multiple EventBusPolicy resources on the same bus coexist.+ try {+ ObjectNode statement = (ObjectNode) ctx.engine().resolveNode(props.get("Statement")).deepCopy();+ statement.put("Sid", statementId);++ EventBus bus = eventBridgeService.describeEventBus(busName, ctx.region());+ ObjectNode policy;+ String current = bus.getPolicy();+ if (current != null && !current.isBlank()) {+ policy = (ObjectNode) MAPPER.readTree(current);+ } else {+ policy = MAPPER.createObjectNode();+ policy.put("Version", "2012-10-17");+ policy.putArray("Statement");+ }+ ArrayNode statements = policy.withArray("Statement");+ for (int i = 0; i < statements.size(); i++) {+ if (statementId.equals(statements.get(i).path("Sid").asText(null))) {+ statements.remove(i);+ break;+ }+ }+ statements.add(statement);+ eventBridgeService.putPermission(busName, null, null, statementId, null,+ MAPPER.writeValueAsString(policy), ctx.region());+ } catch (AwsException e) {+ throw e;+ } catch (Exception e) {+ throw new AwsException("ValidationException",+ "Invalid EventBusPolicy Statement: " + e.getMessage(), 400);+ }+ r.setPhysicalId(busName + "|" + statementId);+ return;+ }++ // Individual form: Action + Principal (+ optional Condition {Type, Key, Value}).+ String action = ctx.resolveOptional(props, "Action");+ String principal = ctx.resolveOptional(props, "Principal");+ String conditionJson = null;+ if (props != null && props.has("Condition") && !props.get("Condition").isNull()) {+ JsonNode c = ctx.engine().resolveNode(props.get("Condition"));+ String type = c.path("Type").asText(null);+ String key = c.path("Key").asText(null);+ String value = c.path("Value").asText(null);+ if (type != null && key != null && value != null) {+ ObjectNode condition = MAPPER.createObjectNode();+ condition.set(type, MAPPER.createObjectNode().put(key, value));+ conditionJson = condition.toString();+ }+ }+ eventBridgeService.putPermission(busName, action, principal, statementId, conditionJson, null, ctx.region());++ r.setPhysicalId(busName + "|" + statementId);+ }++ /**+ * Holds a policy statement id to what the registry schema for {@code AWS::Events::EventBusPolicy}+ * models: {@code [a-zA-Z0-9-_]+}, 1 to 64 characters. Rejecting here is parity first, since AWS+ * refuses the same values, and it also keeps the physical id unambiguous: the id this+ * provisioner assigns is {@code <bus name>|<statement id>}, and neither the modeled bus-name+ * pattern nor this one admits the separator, so {@link #removeEventBusPolicySafe} can always+ * split it back into the pair it was built from.+ */+ private void validateStatementId(String statementId) {+ if (statementId.length() > STATEMENT_ID_MAX_LENGTH+ || !STATEMENT_ID_PATTERN.matcher(statementId).matches()) {+ throw new AwsException("ValidationException",+ "Invalid EventBusPolicy StatementId: " + statementId, 400);+ }+ }++ private void removeEventBusPolicySafe(String physicalId, String region) {+ int sep = physicalId.lastIndexOf('|');+ String busName = sep >= 0 ? physicalId.substring(0, sep) : "default";+ String statementId = sep >= 0 ? physicalId.substring(sep + 1) : physicalId;+ // Only an already-gone bus or statement means "done"; RemovePermission raises+ // ResourceNotFoundException for both. Anything else is a real failure and must reach the+ // stack as DELETE_FAILED rather than being logged away, which is what the previous+ // catch-all did: the statement stayed on the bus and the stack still reported deleted.+ CfnDeletes.safeDelete("Event bus policy statement", physicalId,+ () -> eventBridgeService.removePermission(busName, statementId, false, region),+ "ResourceNotFoundException");+ }+ private static String resolveOrDefault(JsonNode props, String name, ProvisionContext ctx, String defaultValue) {+ String value = ctx.resolveOptional(props, name);+ return (value != null && !value.isBlank()) ? value : defaultValue;+ }++ /** Copied from the monolith: the shared original serves six other callers and stays there. */+ private Map<String, Object> jsonObjectToMap(JsonNode node) {+ Map<String, Object> out = new LinkedHashMap<>();+ node.fields().forEachRemaining(e -> out.put(e.getKey(), jsonNodeToValue(e.getValue())));+ return out;+ }++ private Object jsonNodeToValue(JsonNode node) {+ if (node == null || node.isNull()) {+ return null;+ }+ if (node.isObject()) {+ return jsonObjectToMap(node);+ }+ if (node.isArray()) {+ List<Object> values = new ArrayList<>();+ node.forEach(v -> values.add(jsonNodeToValue(v)));+ return values;+ }+ if (node.isBoolean()) {+ return node.asBoolean();+ }+ if (node.isIntegralNumber()) {+ return node.asLong();+ }+ if (node.isFloatingPointNumber()) {+ return node.asDouble();+ }+ return node.asText();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.javaindex a8abae3c7e..c82b53520f 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/CfnProvisionerFixture.java@@ -30,6 +30,7 @@ import io.github.hectorvent.floci.services.cloudformation.provisioners.ApiGatewaimport io.github.hectorvent.floci.services.cloudformation.provisioners.AutoScalingLifecycleHookCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.AutoScalingScalingPolicyCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.BackupVaultCfnProvisioner;+import io.github.hectorvent.floci.services.cloudformation.provisioners.EventsCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.CdkMetadataCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.CloudTrailCfnProvisioner;import io.github.hectorvent.floci.services.cloudformation.provisioners.CloudWatchCfnProvisioner;@@ -298,6 +299,9 @@ final class CfnProvisionerFixture {if (backupService != null) {discovered.add(new BackupVaultCfnProvisioner(backupService));}+ if (eventBridgeService != null) {+ discovered.add(new EventsCfnProvisioner(eventBridgeService));+ }if (wafV2Service != null) {discovered.add(new WafV2CfnProvisioner(wafV2Service));}@@ -590,7 +594,6 @@ final class CfnProvisionerFixture {ssmService,kmsService,secretsManagerService,- eventBridgeService,apiGatewayService,apiGatewayV2Service,ecrService,diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EventsCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EventsCfnProvisionerTest.javanew file mode 100644index 0000000000..8ac521a72e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/EventsCfnProvisionerTest.java@@ -0,0 +1,356 @@+package io.github.hectorvent.floci.services.cloudformation.provisioners;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ArrayNode;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cloudformation.CloudFormationTemplateEngine;+import io.github.hectorvent.floci.services.cloudformation.model.StackResource;+import io.github.hectorvent.floci.services.eventbridge.EventBridgeService;+import io.github.hectorvent.floci.services.eventbridge.model.Rule;+import io.github.hectorvent.floci.services.eventbridge.model.Target;+import org.junit.jupiter.api.Test;+import org.mockito.ArgumentCaptor;++import java.util.HashMap;+import java.util.List;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertSame;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.doThrow;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.times;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/** The Events CFN provisioner in isolation, with only {@link EventBridgeService} mocked. */+class EventsCfnProvisionerTest {++ private static final String REGION = "us-east-1";+ private static final String RULE_ARN = "arn:aws:events:us-east-1:000000000000:rule/my-stack-Rule-ab12cd";++ private final EventBridgeService events = mock(EventBridgeService.class);+ private final ObjectMapper mapper = new ObjectMapper();+ private final EventsCfnProvisioner provisioner = new EventsCfnProvisioner(events);++ private ProvisionContext ctx(String priorPhysicalId) {+ CloudFormationTemplateEngine engine = mock(CloudFormationTemplateEngine.class);+ when(engine.resolve(any())).thenAnswer(inv -> {+ JsonNode node = inv.getArgument(0);+ return node == null ? null : node.asText();+ });+ when(engine.resolveNode(any())).thenAnswer(inv -> inv.getArgument(0));+ return new ProvisionContext(engine, REGION, "000000000000", "my-stack", priorPhysicalId);+ }++ private StackResource resource(String type, String logicalId) {+ StackResource r = new StackResource();+ r.setResourceType(type);+ r.setLogicalId(logicalId);+ r.setAttributes(new HashMap<>());+ return r;+ }++ private void stubPutRule() {+ Rule rule = new Rule();+ rule.setArn(RULE_ARN);+ when(events.putRule(anyString(), any(), any(), any(), any(), any(), any(), any(), anyString()))+ .thenReturn(rule);+ }++ private ObjectNode target(String id, String arn) {+ return mapper.createObjectNode().put("Id", id).put("Arn", arn);+ }++ private static Target storedTarget(String id) {+ return new Target(id, "arn:aws:sqs:us-east-1:000000000000:q-" + id, null, null);+ }++ // ── the rule keeps its identity across an update ──────────────────────────++ @Test+ void anUnnamedRuleKeepsItsGeneratedNameAcrossUpdates() {+ // The defect: generating unconditionally gave an unnamed rule a fresh random name on every+ // UpdateStack, creating a second rule and leaving the first behind still matching events.+ stubPutRule();+ StackResource r = resource("AWS::Events::Rule", "Rule");++ provisioner.provision(r, mapper.createObjectNode(), ctx("my-stack-Rule-ab12cd"));++ assertEquals("my-stack-Rule-ab12cd", r.getPhysicalId());+ verify(events).putRule(eq("my-stack-Rule-ab12cd"), any(), any(), any(), any(), any(), any(),+ any(), anyString());+ }++ @Test+ void anExplicitlyNamedRuleStillUsesTheTemplateName() {+ stubPutRule();+ StackResource r = resource("AWS::Events::Rule", "Rule");++ provisioner.provision(r, mapper.createObjectNode().put("Name", "orders"), ctx(null));++ assertEquals("orders", r.getPhysicalId());+ assertEquals(RULE_ARN, r.getAttributes().get("Arn"));+ }++ // ── targets are driven to the template's desired state ───────────────────++ @Test+ void aTargetDroppedFromTheTemplateIsRemovedFromTheRule() {+ // PutTargets only upserts by id, so without the sweep a dropped target stayed on the rule+ // and kept receiving events after the template stopped declaring it.+ stubPutRule();+ when(events.listTargetsByRule(anyString(), any(), anyString()))+ .thenReturn(List.of(storedTarget("keep"), storedTarget("gone")));+ ObjectNode props = mapper.createObjectNode().put("Name", "orders");+ props.putArray("Targets").add(target("keep", "arn:aws:sqs:us-east-1:000000000000:q-keep"));++ provisioner.provision(resource("AWS::Events::Rule", "Rule"), props, ctx("orders"));++ ArgumentCaptor<List<String>> removed = ArgumentCaptor.forClass(List.class);+ verify(events).removeTargets(eq("orders"), any(), removed.capture(), anyString());+ assertEquals(List.of("gone"), removed.getValue());+ }++ @Test+ void aTemplateThatDeclaresNoTargetsClearsThem() {+ stubPutRule();+ when(events.listTargetsByRule(anyString(), any(), anyString()))+ .thenReturn(List.of(storedTarget("stale")));++ provisioner.provision(resource("AWS::Events::Rule", "Rule"),+ mapper.createObjectNode().put("Name", "orders"), ctx("orders"));++ ArgumentCaptor<List<String>> removed = ArgumentCaptor.forClass(List.class);+ verify(events).removeTargets(eq("orders"), any(), removed.capture(), anyString());+ assertEquals(List.of("stale"), removed.getValue());+ verify(events, never()).putTargets(anyString(), any(), any(), anyString());+ }++ @Test+ void anUnchangedTargetSetRemovesNothing() {+ stubPutRule();+ when(events.listTargetsByRule(anyString(), any(), anyString()))+ .thenReturn(List.of(storedTarget("keep")));+ ObjectNode props = mapper.createObjectNode().put("Name", "orders");+ props.putArray("Targets").add(target("keep", "arn:aws:sqs:us-east-1:000000000000:q-keep"));++ provisioner.provision(resource("AWS::Events::Rule", "Rule"), props, ctx("orders"));++ verify(events).putTargets(eq("orders"), any(), any(), anyString());+ verify(events, never()).removeTargets(anyString(), any(), any(), anyString());+ }++ // ── a failed policy removal is not swallowed ─────────────────────────────++ @Test+ void anAlreadyGonePolicyStatementCountsAsDeleted() {+ doThrowOnRemovePermission(new AwsException("ResourceNotFoundException",+ "Statement not found: sid-1", 400));++ provisioner.delete("AWS::Events::EventBusPolicy", "orders-bus|sid-1", REGION);++ verify(events).removePermission("orders-bus", "sid-1", false, REGION);+ }++ @Test+ void aFailedPolicyRemovalReachesTheStack() {+ // The previous catch-all logged every failure at debug and returned, so the statement+ // stayed on the bus while the stack still reported DELETE_COMPLETE.+ doThrowOnRemovePermission(new AwsException("ValidationException", "StatementId is required.", 400));++ AwsException thrown = assertThrows(AwsException.class,+ () -> provisioner.delete("AWS::Events::EventBusPolicy", "orders-bus|sid-1", REGION));++ assertEquals("ValidationException", thrown.getErrorCode());+ assertTrue(thrown.getMessage().contains("StatementId"));+ }++ // ── the event bus reads its prior identity from the provision context ─────++ @Test+ void anEventBusUpdateComparesAgainstThePriorIdFromTheContext() {+ // provision assigns the new id as it runs, so the prior name has to come from the context.+ // Reading it off the resource made a rename look like a create and silently switched buses.+ StackResource r = resource("AWS::Events::EventBus", "Bus");++ AwsException thrown = assertThrows(AwsException.class, () -> provisioner.provision(+ r, mapper.createObjectNode().put("Name", "renamed"), ctx("orders-bus")));++ assertTrue(thrown.getMessage().contains("requires resource replacement"));+ }++ // ── the policy statement id is held to the modeled pattern ────────────────++ @Test+ void aStatementIdCarryingTheIdSeparatorIsRejected() {+ // AWS models StatementId as [a-zA-Z0-9-_]+, so a pipe cannot reach the service. Refusing it+ // is parity first, and it also keeps "<bus>|<sid>" splittable back into the pair.+ AwsException thrown = assertThrows(AwsException.class, () -> provisioner.provision(+ resource("AWS::Events::EventBusPolicy", "Policy"),+ policyProps("orders-bus|sid"), ctx(null)));++ assertEquals("ValidationException", thrown.getErrorCode());+ assertTrue(thrown.getMessage().contains("StatementId"));+ }++ @Test+ void aStatementIdBeyondTheModeledLengthIsRejected() {+ AwsException thrown = assertThrows(AwsException.class, () -> provisioner.provision(+ resource("AWS::Events::EventBusPolicy", "Policy"),+ policyProps("s".repeat(65)), ctx(null)));++ assertEquals("ValidationException", thrown.getErrorCode());+ verify(events, never()).putPermission(anyString(), any(), any(), anyString(), any(), any(), anyString());+ }++ private ObjectNode policyProps(String statementId) {+ return mapper.createObjectNode()+ .put("EventBusName", "orders-bus")+ .put("StatementId", statementId)+ .put("Action", "events:PutEvents")+ .put("Principal", "111122223333");+ }++ private void doThrowOnRemovePermission(AwsException e) {+ org.mockito.Mockito.doThrow(e).when(events)+ .removePermission(anyString(), anyString(), org.mockito.ArgumentMatchers.anyBoolean(), anyString());+ }++ // ── a failed stack update puts the rule's targets back ────────────────────++ private static final String RULE_TARGETS_SNAPSHOT_ATTR = CfnRollback.RULE_TARGETS_SNAPSHOT_ATTR;++ @Test+ void aRollbackPutsBackATargetTheUpdateDropped() {+ // Before the snapshot, the reconciliation sweep could delete a live target and a later+ // resource's failure left it deleted: the rule stopped delivering to it for good.+ stubPutRule();+ stubTargetSequence(List.of(storedTarget("keep"), storedTarget("gone")),+ List.of(storedTarget("keep"), storedTarget("gone")),+ List.of(storedTarget("keep")));+ StackResource r = updatedRuleWithTargets("keep");++ assertTrue(provisioner.rollbackUpdate(r));++ assertEquals(List.of("keep", "gone"), idsOfPutTargets(2).get(1));+ assertNull(r.getAttributes().get(RULE_TARGETS_SNAPSHOT_ATTR));+ }++ @Test+ void aRollbackRemovesATargetTheUpdateAdded() {+ // The restore is exact, not additive: what the failed update added does not survive it.+ stubPutRule();+ stubTargetSequence(List.of(storedTarget("keep")),+ List.of(storedTarget("keep"), storedTarget("added")),+ List.of(storedTarget("keep"), storedTarget("added")));+ StackResource r = updatedRuleWithTargets("keep", "added");++ assertTrue(provisioner.rollbackUpdate(r));++ ArgumentCaptor<List<String>> removed = ArgumentCaptor.forClass(List.class);+ verify(events).removeTargets(eq("orders"), any(), removed.capture(), anyString());+ assertEquals(List.of("added"), removed.getValue());+ assertEquals(List.of("keep"), idsOfPutTargets(2).get(1));+ }++ @Test+ void aRuleThisRunNeverTouchedIsNotRolledBack() {+ // Answering true here would clear the targets of a rule the update never reconciled. False+ // is what makes the stack keep reporting that rollback is not implemented for it.+ StackResource r = resource("AWS::Events::Rule", "Rule");+ r.setPhysicalId("orders");++ assertFalse(provisioner.rollbackUpdate(r));++ verify(events, never()).putTargets(anyString(), any(), any(), anyString());+ verify(events, never()).removeTargets(anyString(), any(), any(), anyString());+ }++ @Test+ void aFailedReconciliationRestoresTheTargetsAndRethrowsTheFailure() {+ stubPutRule();+ stubTargetSequence(List.of(storedTarget("keep"), storedTarget("gone")),+ List.of(storedTarget("keep"), storedTarget("gone")));+ AwsException putFailure = new AwsException("ValidationException", "Too many targets", 400);+ when(events.putTargets(anyString(), any(), any(), anyString())).thenThrow(putFailure).thenReturn(1);+ StackResource r = resource("AWS::Events::Rule", "Rule");++ AwsException thrown = assertThrows(AwsException.class,+ () -> provisioner.provision(r, ruleProps("keep"), ctx("orders")));++ assertSame(putFailure, thrown);+ assertEquals(List.of("keep", "gone"), idsOfPutTargets(2).get(1));+ assertNull(r.getAttributes().get(CfnRollback.UPDATE_ROLLBACK_FAILURE_ATTR));+ assertNull(r.getAttributes().get(RULE_TARGETS_SNAPSHOT_ATTR));+ }++ @Test+ void aRestoreThatAlsoFailsIsRecordedOnTheResource() {+ // The stack has to report UPDATE_ROLLBACK_FAILED naming this rule rather than claiming the+ // prior targets are live, so the restore failure goes on the resource instead of being+ // thrown over the failure that is already on its way out.+ stubPutRule();+ stubTargetSequence(List.of(storedTarget("keep"), storedTarget("gone")),+ List.of(storedTarget("keep"), storedTarget("gone")));+ AwsException putFailure = new AwsException("ValidationException", "Too many targets", 400);+ doThrow(putFailure).when(events).putTargets(anyString(), any(), any(), anyString());+ StackResource r = resource("AWS::Events::Rule", "Rule");++ assertThrows(AwsException.class, () -> provisioner.provision(r, ruleProps("keep"), ctx("orders")));++ assertEquals("Too many targets", r.getAttributes().get(CfnRollback.UPDATE_ROLLBACK_FAILURE_ATTR));+ }++ @Test+ void aCreateTakesNoSnapshotToRollBack() {+ stubPutRule();++ StackResource r = resource("AWS::Events::Rule", "Rule");+ provisioner.provision(r, ruleProps("keep"), ctx(null));++ assertNull(r.getAttributes().get(RULE_TARGETS_SNAPSHOT_ATTR));+ assertFalse(provisioner.rollbackUpdate(r));+ }++ /** Runs an update that reconciles the rule down to {@code desiredIds}, and returns the resource. */+ private StackResource updatedRuleWithTargets(String... desiredIds) {+ StackResource r = resource("AWS::Events::Rule", "Rule");+ provisioner.provision(r, ruleProps(desiredIds), ctx("orders"));+ return r;+ }++ private ObjectNode ruleProps(String... targetIds) {+ ObjectNode props = mapper.createObjectNode().put("Name", "orders");+ ArrayNode declared = props.putArray("Targets");+ for (String id : targetIds) {+ declared.add(target(id, "arn:aws:sqs:us-east-1:000000000000:q-" + id));+ }+ return props;+ }++ /** Successive answers from ListTargetsByRule, in the order the run asks for them. */+ @SafeVarargs+ private void stubTargetSequence(List<Target> first, List<Target>... rest) {+ var stub = when(events.listTargetsByRule(anyString(), any(), anyString())).thenReturn(first);+ for (List<Target> answer : rest) {+ stub = stub.thenReturn(answer);+ }+ }++ /** The target ids of each PutTargets call, in order, asserting there were exactly {@code n}. */+ private List<List<String>> idsOfPutTargets(int n) {+ ArgumentCaptor<List<Target>> put = ArgumentCaptor.forClass(List.class);+ verify(events, times(n)).putTargets(eq("orders"), any(), put.capture(), anyString());+ return put.getAllValues().stream().map(call -> call.stream().map(Target::getId).toList()).toList();+ }+}diff --git a/src/test/resources/cloudformation/supported-resource-types.tsv b/src/test/resources/cloudformation/supported-resource-types.tsvindex 9ef1d3caf2..60308dcd7c 100644--- a/src/test/resources/cloudformation/supported-resource-types.tsv+++ b/src/test/resources/cloudformation/supported-resource-types.tsv@@ -71,9 +71,9 @@ AWS::ElasticLoadBalancingV2::Listener ElbV2CfnProvisionerAWS::ElasticLoadBalancingV2::ListenerRule ElbV2CfnProvisionerAWS::ElasticLoadBalancingV2::LoadBalancer ElbV2CfnProvisionerAWS::ElasticLoadBalancingV2::TargetGroup ElbV2CfnProvisioner-AWS::Events::EventBus LEGACY_SWITCH-AWS::Events::EventBusPolicy LEGACY_SWITCH-AWS::Events::Rule LEGACY_SWITCH+AWS::Events::EventBus EventsCfnProvisioner+AWS::Events::EventBusPolicy EventsCfnProvisioner+AWS::Events::Rule EventsCfnProvisionerAWS::IAM::AccessKey LEGACY_SWITCHAWS::IAM::InstanceProfile LEGACY_SWITCHAWS::IAM::ManagedPolicy LEGACY_SWITCH