diff --git a/src/main/java/io/floci/aws/services/s3/S3Service.java b/src/main/java/io/floci/aws/services/s3/S3Service.java index d3564924368..515ba3635a2 100644 --- a/src/main/java/io/floci/aws/services/s3/S3Service.java +++ b/src/main/java/io/floci/aws/services/s3/S3Service.java @@ -7399,13 +7399,14 @@ private void fireNotifications(String bucketName, String key, String eventName, if (config.isEventBridgeEnabled() && eventBridgeService != null) { try { - String detailType = eventName.startsWith("ObjectCreated") ? "Object Created" - : eventName.startsWith("ObjectAnnotation") ? "Object Annotation" - : "Object Deleted"; - Map entry = new java.util.HashMap<>(); - entry.put("Source", "aws.s3"); - entry.put("DetailType", detailType); - entry.put("Detail", buildS3EventBridgeDetail(bucketName, key, eventName, obj, region)); + String detailType = switch (eventName) { + case "ObjectAnnotation:Put" -> "Object Annotation Created"; + case "ObjectAnnotation:Delete" -> "Object Annotation Removed"; + default -> eventName.startsWith("ObjectCreated") ? "Object Created" : "Object Deleted"; + }; + Map entry = EventBridgeService.serviceEventEntry("aws.s3", detailType, + buildS3EventBridgeDetail(bucketName, key, eventName, obj, region), + S3ResourceArns.bucket(bucketPartition(bucketName), bucketName)); eventBridgeService.putEvents(List.of(entry), region); LOG.debugv("Fired S3 event {0} to EventBridge default bus", eventName); } catch (Exception e) { @@ -7450,9 +7451,18 @@ private String buildS3EventBridgeDetail(String bucketName, String key, String ev } } - /** The EventBridge {@code reason}: {@code Lifecycle Expiration} for a deletion by a lifecycle rule. */ + /** EventBridge names the API rather than the classic notification event. */ private static String eventBridgeReason(String eventName) { - return isLifecycleEvent(eventName) ? "Lifecycle Expiration" : eventName; + return switch (eventName) { + case "ObjectCreated:Put" -> "PutObject"; + case "ObjectCreated:Post" -> "POST Object"; + case "ObjectCreated:Copy" -> "CopyObject"; + case "ObjectCreated:CompleteMultipartUpload" -> "CompleteMultipartUpload"; + case "ObjectRemoved:Delete", "ObjectRemoved:DeleteMarkerCreated" -> "DeleteObject"; + case "ObjectAnnotation:Put" -> "PutObjectAnnotation"; + case "ObjectAnnotation:Delete" -> "DeleteObjectAnnotation"; + default -> isLifecycleEvent(eventName) ? "Lifecycle Expiration" : eventName; + }; } private static boolean isLifecycleEvent(String eventName) { diff --git a/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java b/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java new file mode 100644 index 00000000000..3da3a311598 --- /dev/null +++ b/src/test/java/io/floci/aws/services/s3/S3EventBridgeEventShapeIntegrationTest.java @@ -0,0 +1,134 @@ +package io.floci.aws.services.s3; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import io.floci.aws.testing.AwsTestClients; +import io.floci.aws.testing.EnforcementFixtures; +import io.floci.aws.testing.EventRuleQueue; +import io.floci.aws.testing.PartitionCleanup; +import io.floci.aws.testing.RestAssuredJsonUtils; +import io.quarkus.test.junit.QuarkusTest; +import io.restassured.RestAssured; +import jakarta.inject.Inject; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.extension.RegisterExtension; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import software.amazon.awssdk.core.sync.RequestBody; +import software.amazon.awssdk.regions.Region; +import software.amazon.awssdk.services.eventbridge.EventBridgeClient; +import software.amazon.awssdk.services.s3.S3Client; +import software.amazon.awssdk.services.s3.model.CompletedPart; + +import java.nio.charset.StandardCharsets; +import java.util.List; +import java.util.UUID; + +import static io.restassured.RestAssured.given; +import static org.junit.jupiter.api.Assertions.*; + +@QuarkusTest +class S3EventBridgeEventShapeIntegrationTest { + + private static final String ACCOUNT = "000000000000"; + + @Inject + ObjectMapper objectMapper; + + @RegisterExtension + final PartitionCleanup cleanup = new PartitionCleanup(); + + @BeforeAll + static void configureAwsContentTypes() { + RestAssuredJsonUtils.configureAwsContentTypes(); + } + + @ParameterizedTest + @CsvSource({ + "us-east-1,aws,PutObject,PutObject,Object Created", + "us-east-1,aws,POST Object,POST Object,Object Created", + "us-east-1,aws,CopyObject,CopyObject,Object Created", + "us-east-1,aws,CompleteMultipartUpload,CompleteMultipartUpload,Object Created", + "cn-north-1,aws-cn,PutObject,PutObject,Object Created", + "us-east-1,aws,DeleteObject,DeleteObject,Object Deleted", + "us-east-1,aws,DeleteMarker,DeleteObject,Object Deleted", + "us-east-1,aws,PutObjectAnnotation,PutObjectAnnotation,Object Annotation Created", + "us-east-1,aws,DeleteObjectAnnotation,DeleteObjectAnnotation,Object Annotation Removed" + }) + void eventCarriesApiReasonAndBucketArn(String regionId, String partition, String operation, + String reason, String detailType) throws Exception { + Region region = Region.of(regionId); + String name = "s3-eb-shape-" + UUID.randomUUID(); + String bucketArn = "arn:" + partition + ":s3:::" + name; + String authorization = EnforcementFixtures.auth(ACCOUNT, regionId, "s3"); + String pattern = "{\"source\":[\"aws.s3\"],\"detail\":{\"bucket\":{\"name\":[\"" + name + "\"]}}}"; + try (S3Client s3 = AwsTestClients.create(S3Client.builder().forcePathStyle(true), ACCOUNT, region); + EventBridgeClient events = AwsTestClients.create(EventBridgeClient.builder(), ACCOUNT, region); + EventRuleQueue queue = EventRuleQueue.route(ACCOUNT, regionId, name, pattern)) { + s3.createBucket(request -> { + request.bucket(name); + if (!region.equals(Region.US_EAST_1)) { + request.createBucketConfiguration(configuration -> configuration.locationConstraint(regionId)); + } + }); + int port = RestAssured.port; + cleanup.register(() -> EnforcementFixtures.removeBucket(port, authorization, name)); + if (operation.equals("DeleteMarker")) { + s3.putBucketVersioning(request -> request.bucket(name) + .versioningConfiguration(configuration -> configuration.status("Enabled"))); + } + // Seed inputs before enabling notifications so only the operation under test is delivered. + s3.putObject(request -> request.bucket(name).key("source"), RequestBody.fromString("content")); + if (operation.startsWith("Delete") || operation.equals("PutObjectAnnotation")) { + s3.putObject(request -> request.bucket(name).key("created"), RequestBody.fromString("content")); + } + if (operation.equals("DeleteObjectAnnotation")) { + given().header("Authorization", authorization).queryParam("annotation", "") + .queryParam("annotationName", "note").body("{}").put("/" + name + "/created") + .then().statusCode(200); + } + s3.putBucketNotificationConfiguration(request -> request.bucket(name) + .notificationConfiguration(configuration -> configuration.eventBridgeConfiguration(bridge -> {}))); + + switch (operation) { + case "PutObject" -> s3.putObject(request -> request.bucket(name).key("created"), + RequestBody.fromString("content")); + case "POST Object" -> given().header("Authorization", authorization) + .multiPart("key", "created") + .multiPart("file", "created", "content".getBytes(StandardCharsets.UTF_8), "text/plain") + .when().post("/" + name).then().statusCode(204); + case "CopyObject" -> s3.copyObject(request -> request.copySource(name + "/source") + .destinationBucket(name).destinationKey("created")); + case "CompleteMultipartUpload" -> { + String uploadId = s3.createMultipartUpload(request -> request.bucket(name).key("created")).uploadId(); + String etag = s3.uploadPart(request -> request.bucket(name).key("created") + .uploadId(uploadId).partNumber(1), RequestBody.fromString("content")).eTag(); + s3.completeMultipartUpload(request -> request.bucket(name).key("created").uploadId(uploadId) + .multipartUpload(upload -> upload.parts(CompletedPart.builder() + .partNumber(1).eTag(etag).build()))); + } + case "DeleteObject", "DeleteMarker" -> s3.deleteObject(request -> request.bucket(name).key("created")); + case "PutObjectAnnotation" -> given().header("Authorization", authorization).queryParam("annotation", "") + .queryParam("annotationName", "note").body("{}").put("/" + name + "/created") + .then().statusCode(200); + case "DeleteObjectAnnotation" -> given().header("Authorization", authorization).queryParam("annotation", "") + .queryParam("annotationName", "note").delete("/" + name + "/created").then().statusCode(204); + default -> throw new AssertionError("Unknown S3 API: " + operation); + } + + List messages = queue.drain(); + assertEquals(1, messages.size(), "Expected the S3 event through EventBridge and SQS"); + JsonNode event = messages.getFirst(); + String consumerPattern = "{\"source\":[\"aws.s3\"],\"resources\":[\"" + bucketArn + + "\"],\"detail\":{\"reason\":[\"" + reason + "\"]}}"; + assertAll( + () -> assertEquals(detailType, event.path("detail-type").asText()), + () -> assertEquals(regionId, event.path("region").asText()), + () -> assertEquals("created", event.path("detail").path("object").path("key").asText()), + () -> assertEquals(reason, event.path("detail").path("reason").asText()), + () -> assertEquals(objectMapper.valueToTree(List.of(bucketArn)), event.path("resources")), + () -> assertTrue(events.testEventPattern(request -> request.eventPattern(consumerPattern) + .event(event.toString())).result(), "Consumers must be able to filter on the API reason and bucket ARN")); + } + } +} diff --git a/src/test/java/io/floci/aws/testing/EventRuleQueue.java b/src/test/java/io/floci/aws/testing/EventRuleQueue.java index f3de60eb32c..3bbceb41ba1 100644 --- a/src/test/java/io/floci/aws/testing/EventRuleQueue.java +++ b/src/test/java/io/floci/aws/testing/EventRuleQueue.java @@ -45,16 +45,26 @@ public static EventRuleQueue route(String region, String name, String pattern) { public static EventRuleQueue route(String account, String region, String name, String pattern) { String url = call(account, region, "sqs", "AmazonSQS.CreateQueue", SQS_CONTENT_TYPE, MAPPER.createObjectNode().put("QueueName", name)).jsonPath().getString("QueueUrl"); - ObjectNode attributes = MAPPER.createObjectNode().put("QueueUrl", url); - attributes.putArray("AttributeNames").add("QueueArn"); - String arn = call(account, region, "sqs", "AmazonSQS.GetQueueAttributes", SQS_CONTENT_TYPE, attributes) - .jsonPath().getString("Attributes.QueueArn"); - call(account, region, "events", "AWSEvents.PutRule", EVENTS_CONTENT_TYPE, - MAPPER.createObjectNode().put("Name", name).put("EventPattern", pattern)); - ObjectNode targets = MAPPER.createObjectNode().put("Rule", name); - targets.putArray("Targets").addObject().put("Id", TARGET_ID).put("Arn", arn); - call(account, region, "events", "AWSEvents.PutTargets", EVENTS_CONTENT_TYPE, targets); - return new EventRuleQueue(account, region, name, url); + EventRuleQueue queue = new EventRuleQueue(account, region, name, url); + try { + ObjectNode attributes = MAPPER.createObjectNode().put("QueueUrl", url); + attributes.putArray("AttributeNames").add("QueueArn"); + String arn = call(account, region, "sqs", "AmazonSQS.GetQueueAttributes", SQS_CONTENT_TYPE, attributes) + .jsonPath().getString("Attributes.QueueArn"); + call(account, region, "events", "AWSEvents.PutRule", EVENTS_CONTENT_TYPE, + MAPPER.createObjectNode().put("Name", name).put("EventPattern", pattern)); + ObjectNode targets = MAPPER.createObjectNode().put("Rule", name); + targets.putArray("Targets").addObject().put("Id", TARGET_ID).put("Arn", arn); + call(account, region, "events", "AWSEvents.PutTargets", EVENTS_CONTENT_TYPE, targets); + return queue; + } catch (RuntimeException | AssertionError failure) { + try { + queue.close(); + } catch (RuntimeException | AssertionError cleanupFailure) { + failure.addSuppressed(cleanupFailure); + } + throw failure; + } } /** @@ -85,11 +95,17 @@ public List drain() throws Exception { public void close() { ObjectNode targets = MAPPER.createObjectNode().put("Rule", name); targets.putArray("Ids").add(TARGET_ID); - call(account, region, "events", "AWSEvents.RemoveTargets", EVENTS_CONTENT_TYPE, targets); - call(account, region, "events", "AWSEvents.DeleteRule", EVENTS_CONTENT_TYPE, - MAPPER.createObjectNode().put("Name", name)); - call(account, region, "sqs", "AmazonSQS.DeleteQueue", SQS_CONTENT_TYPE, - MAPPER.createObjectNode().put("QueueUrl", url)); + try { + call(account, region, "events", "AWSEvents.RemoveTargets", EVENTS_CONTENT_TYPE, targets); + } finally { + try { + call(account, region, "events", "AWSEvents.DeleteRule", EVENTS_CONTENT_TYPE, + MAPPER.createObjectNode().put("Name", name)); + } finally { + call(account, region, "sqs", "AmazonSQS.DeleteQueue", SQS_CONTENT_TYPE, + MAPPER.createObjectNode().put("QueueUrl", url)); + } + } } private static Response call(String account, String region, String service, String target, diff --git a/src/test/java/io/floci/aws/testing/EventRuleQueueTest.java b/src/test/java/io/floci/aws/testing/EventRuleQueueTest.java new file mode 100644 index 00000000000..46e092db7a5 --- /dev/null +++ b/src/test/java/io/floci/aws/testing/EventRuleQueueTest.java @@ -0,0 +1,67 @@ +package io.floci.aws.testing; + +import io.restassured.RestAssured; +import io.restassured.builder.ResponseBuilder; +import io.restassured.filter.Filter; +import io.restassured.response.Response; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.atomic.AtomicBoolean; + +import static org.junit.jupiter.api.Assertions.*; + +class EventRuleQueueTest { + + @ParameterizedTest + @ValueSource(strings = {"AmazonSQS.GetQueueAttributes", "AWSEvents.PutRule", "AWSEvents.PutTargets"}) + void setupFailureStillDeletesTheCreatedQueue(String failingAction) { + List actions = new ArrayList<>(); + List original = RestAssured.filters(); + RestAssured.replaceFiltersWith((request, response, context) -> { + String action = request.getHeaders().getValue("X-Amz-Target"); + actions.add(action); + return response(action.equals(failingAction) ? 500 : 200); + }); + try { + assertThrows(AssertionError.class, () -> EventRuleQueue.route("us-east-1", "cleanup", "{}")); + assertTrue(actions.contains("AmazonSQS.DeleteQueue"), actions.toString()); + if (!failingAction.equals("AmazonSQS.GetQueueAttributes")) { + assertTrue(actions.contains("AWSEvents.DeleteRule"), actions.toString()); + } + } finally { + RestAssured.replaceFiltersWith(original); + } + } + + @Test + void failingTargetRemovalStillDeletesTheRuleAndQueue() { + List actions = new ArrayList<>(); + AtomicBoolean closing = new AtomicBoolean(); + List original = RestAssured.filters(); + RestAssured.replaceFiltersWith((request, response, context) -> { + String action = request.getHeaders().getValue("X-Amz-Target"); + actions.add(action); + return response(closing.get() && action.equals("AWSEvents.RemoveTargets") ? 500 : 200); + }); + try { + EventRuleQueue queue = EventRuleQueue.route("us-east-1", "cleanup", "{}"); + closing.set(true); + assertThrows(AssertionError.class, queue::close); + assertTrue(actions.contains("AWSEvents.DeleteRule"), actions.toString()); + assertTrue(actions.contains("AmazonSQS.DeleteQueue"), actions.toString()); + } finally { + RestAssured.replaceFiltersWith(original); + } + } + + private static Response response(int status) { + return new ResponseBuilder().setStatusCode(status).setContentType("application/json") + .setBody("{\"QueueUrl\":\"http://localhost/queue\"," + + "\"Attributes\":{\"QueueArn\":\"arn:aws:sqs:us-east-1:000000000000:q\"}," + + "\"FailedEntryCount\":0}").build(); + } +}