Light, fluffy, and always free - The AWS Local Emulator alternative
feat(oam): emulate observability access manager (#3440)
Franklin G. Mendozaa0fd815366ab
diff --git a/README.md b/README.mdindex 3800690d9e..66ff7d24c7 100644--- a/README.md+++ b/README.md@@ -232,7 +232,7 @@ Floci supports local emulation for application services, data services, eventing| Category | Services ||---|---|| Core app services | S3, SQS, SNS, DynamoDB, Lambda, IAM, KMS, Secrets Manager, SSM |-| Events and workflows | EventBridge, EventBridge Pipes, EventBridge Scheduler, Step Functions, SWF, CloudWatch Logs, CloudWatch Metrics, CloudWatch RUM, Managed Prometheus (AMP) |+| Events and workflows | EventBridge, EventBridge Pipes, EventBridge Scheduler, Step Functions, SWF, CloudWatch Logs, CloudWatch Metrics, CloudWatch OAM, CloudWatch RUM, Managed Prometheus (AMP) || API and identity | API Gateway REST, API Gateway v2, AppSync, Cognito, ACM, Route53, Route 53 Resolver, Cloud Map, Global Accelerator || Containers and compute | ECS, EC2, Lightsail, EKS, MWAA, ECR, EFS, CodeBuild, CodeDeploy, CodePipeline, CodeGuru Reviewer, AWS Batch, Auto Scaling, Application Auto Scaling, Elastic Beanstalk, ELB v2, ELB Classic || Data, analytics, and AI | Athena, Glue, Lake Formation, EMR, EMR Serverless, Redshift, Redshift Data API, Firehose, Managed Service for Apache Flink, OpenSearch, S3 Tables, S3 Vectors, Textract, Transcribe, Comprehend, Rekognition, Translate, Bedrock, Bedrock Runtime, Bedrock AgentCore |@@ -272,6 +272,7 @@ For operation-level compatibility, see the [Services Overview](https://floci.io/| EventBridge Scheduler | In-process | Schedule groups, schedules, flexible time windows, retry policies, DLQs || CloudWatch Logs | In-process | Log groups, streams, ingestion, filtering || CloudWatch Metrics | In-process | Custom metrics, statistics, alarms |+| CloudWatch OAM | In-process | Full 15-operation sink, policy, cross-account link, and tagging API || ElastiCache | Real Docker | Redis / Valkey protocol, IAM auth, SigV4 validation || MemoryDB | Real Docker | Redis / Valkey protocol via real containers; JSON 1.1 control plane; reuses ElastiCache RESP proxy || RDS | Real Docker | PostgreSQL, MySQL, MariaDB, IAM auth, JDBC-compatible engines |diff --git a/compatibility-tests/sdk-test-java/pom.xml b/compatibility-tests/sdk-test-java/pom.xmlindex 334324f35c..3f0d2288fb 100644--- a/compatibility-tests/sdk-test-java/pom.xml+++ b/compatibility-tests/sdk-test-java/pom.xml@@ -512,6 +512,11 @@<groupId>software.amazon.awssdk</groupId><artifactId>resourceexplorer2</artifactId></dependency>+ <!-- CloudWatch OAM client -->+ <dependency>+ <groupId>software.amazon.awssdk</groupId>+ <artifactId>oam</artifactId>+ </dependency><!-- SSO credential support (needed for FLOCI_TARGET=aws with SSO profiles) --><dependency><groupId>software.amazon.awssdk</groupId>diff --git a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.javaindex 5896826697..baa8938f2f 100644--- a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java+++ b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java@@ -26,6 +26,7 @@ import software.amazon.awssdk.http.Protocol;import software.amazon.awssdk.services.kms.KmsClient;import software.amazon.awssdk.services.lambda.LambdaClient;import software.amazon.awssdk.services.opensearch.OpenSearchClient;+import software.amazon.awssdk.services.oam.OamClient;import software.amazon.awssdk.services.neptune.NeptuneClient;import software.amazon.awssdk.services.rds.RdsClient;import software.amazon.awssdk.services.redshift.RedshiftClient;@@ -1294,6 +1295,14 @@ public final class TestFixtures {.build();}+ public static OamClient oamClient() {+ return OamClient.builder()+ .endpointOverride(ENDPOINT)+ .region(REGION)+ .credentialsProvider(CREDENTIALS)+ .build();+ }+public static ResourceExplorer2Client resourceExplorer2Client() {return resourceExplorer2Client(REGION);}diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/OamTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/OamTest.javanew file mode 100644index 0000000000..4b015403c9--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/OamTest.java@@ -0,0 +1,28 @@+package com.floci.test;++import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.oam.OamClient;+import software.amazon.awssdk.services.oam.model.CreateSinkRequest;+import software.amazon.awssdk.services.oam.model.DeleteSinkRequest;+import software.amazon.awssdk.services.oam.model.GetSinkRequest;+import software.amazon.awssdk.services.oam.model.ListSinksRequest;++import static org.junit.jupiter.api.Assertions.*;++class OamTest {+ @Test+ void sinkLifecycle() {+ try (OamClient client = TestFixtures.oamClient()) {+ var created = client.createSink(CreateSinkRequest.builder().name("sdk-oam-sink").build());+ assertNotNull(created.arn());+ assertEquals("sdk-oam-sink", created.name());++ var fetched = client.getSink(GetSinkRequest.builder().identifier(created.arn()).build());+ assertEquals(created.arn(), fetched.arn());+ assertTrue(client.listSinks(ListSinksRequest.builder().build()).items().stream()+ .anyMatch(item -> created.arn().equals(item.arn())));++ client.deleteSink(DeleteSinkRequest.builder().identifier(created.arn()).build());+ }+ }+}diff --git a/docs/services/index.md b/docs/services/index.mdindex ac898c1320..7d0986233b 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -41,6 +41,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [EventBridge](eventbridge.md) | `POST /` + `X-Amz-Target: AmazonEventBridge.*` | JSON 1.1 | 16 || [EventBridge Scheduler](scheduler.md) | `/schedules/*`, `/schedule-groups/*`, `/tags/*` | REST JSON | 12 || [EventBridge Pipes](pipes.md) | `/v1/pipes/*` | REST JSON | 7 |+| [CloudWatch OAM](oam.md) | REST paths such as `POST /CreateSink` and `POST /CreateLink` | REST JSON | 15 || [CloudWatch Logs](cloudwatch.md) | `POST /` + `X-Amz-Target: Logs.*` | JSON 1.1 | 17 || [CloudWatch Metrics](cloudwatch.md#metrics) | `POST /` with `Action=` or JSON 1.1 | Query / JSON | 11 || [CloudWatch RUM](rum.md) | `/appmonitor`, `/appmonitor/{name}`, `/appmonitors` | REST JSON | 5 |diff --git a/docs/services/oam.md b/docs/services/oam.mdnew file mode 100644index 0000000000..3d047d9458--- /dev/null+++ b/docs/services/oam.md@@ -0,0 +1,85 @@+# CloudWatch Observability Access Manager (`oam:*`)++**Protocol:** REST JSON+**Signing name:** `oam`+**API version:** `2022-06-10`++Floci emulates the CloudWatch Observability Access Manager control plane for cross-account observability links. Sinks and links are account and Region scoped, and attached-link discovery crosses source-account storage partitions in the same way the AWS API exposes source links to a monitoring sink.++## Supported operations++| Operation | Notes |+|---|---|+| `CreateSink` | Creates the single sink allowed for the calling account and Region |+| `GetSink` | Returns one sink by ARN |+| `ListSinks` | Lists sinks for the calling account and Region |+| `PutSinkPolicy` | Stores and validates the sink resource policy |+| `GetSinkPolicy` | Returns the current policy for a sink |+| `DeleteSink` | Rejects deletion while links remain attached |+| `CreateLink` | Creates a source-account link after evaluating the sink policy |+| `GetLink` | Returns one source-account link |+| `ListLinks` | Lists links owned by the calling source account |+| `ListAttachedLinks` | Lists links from all source accounts attached to a sink |+| `UpdateLink` | Replaces shared resource types and optional metric/log filters |+| `DeleteLink` | Deletes a source-account link |+| `ListTagsForResource` | Returns tags for a sink or link |+| `TagResource` | Adds or replaces tags on a sink or link |+| `UntagResource` | Removes tag keys from a sink or link |++## Sink policies++`PutSinkPolicy` accepts IAM-style JSON policies. For `CreateLink`, Floci evaluates the policy's `Effect`, `Principal`, `Action`, `Resource`, and the `oam:ResourceTypes` condition. Individual account principals, account root ARNs, wildcard principals, exact sink ARNs, and wildcard resources are supported.++Organization-based conditions are not currently resolved through AWS Organizations metadata. Policies that depend on organization condition keys should use explicit account principals when testing locally.++## Resource types and filters++Floci accepts the resource types modeled by the current OAM API:++- `AWS::CloudWatch::Metric`+- `AWS::Logs::LogGroup`+- `AWS::XRay::Trace`+- `AWS::ApplicationInsights::Application`+- `AWS::InternetMonitor::Monitor`+- `AWS::ApplicationSignals::Service`+- `AWS::ApplicationSignals::ServiceLevelObjective`++Metric and log-group filters are persisted with the link. Updating a filter to `*` removes that filter, matching the AWS update contract.++## Quotas and validation++- One sink per account per Region.+- Up to five links per source account per Region.+- `ListSinks` accepts `MaxResults` from 1 to 100.+- `ListLinks` accepts `MaxResults` from 1 to 5.+- `ListAttachedLinks` accepts `MaxResults` from 1 to 1000.+- A sink cannot be deleted while links are attached.+- Sinks and links support up to 50 tags.++Floci resolves the account-derived label variables to the local account ID because the emulator has no AWS account email/name directory attached to OAM itself.++## Configuration++| Variable | Default | Description |+|---|---|---|+| `FLOCI_SERVICES_OAM_ENABLED` | `true` | Enable or disable OAM |++## Example++```bash+export AWS_ENDPOINT_URL=http://localhost:4566+export AWS_DEFAULT_REGION=us-east-1+export AWS_ACCESS_KEY_ID=test+export AWS_SECRET_ACCESS_KEY=test++sink_arn=$(aws oam create-sink --name local-observability --query Arn --output text)++aws oam put-sink-policy \+ --sink-identifier "$sink_arn" \+ --policy '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":"*","Action":"oam:CreateLink","Resource":"*"}]}'++aws oam create-link \+ --sink-identifier "$sink_arn" \+ --label-template local-source \+ --resource-types AWS::CloudWatch::Metric AWS::Logs::LogGroup+```diff --git a/mkdocs.yml b/mkdocs.ymlindex f42f797d54..b45cca9cf7 100644--- a/mkdocs.yml+++ b/mkdocs.yml@@ -154,6 +154,7 @@ nav:- EventBridge Pipes: services/pipes.md- EventBridge Scheduler: services/scheduler.md- CloudWatch: services/cloudwatch.md+ - CloudWatch OAM: services/oam.md- CloudWatch RUM: services/rum.md- Managed Prometheus (AMP): services/managed-prometheus.md- GuardDuty: services/guardduty.mddiff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 1c1646d949..0aa7eb9e72 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -703,6 +703,7 @@ public interface EmulatorConfig {CostExplorerServiceConfig ce();CurServiceConfig cur();BcmDataExportsServiceConfig bcmDataExports();+ OamServiceConfig oam();ConfigServiceConfig configservice();CloudTrailServiceConfig cloudtrail();CloudControlServiceConfig cloudcontrol();@@ -1922,6 +1923,11 @@ public interface EmulatorConfig {int schemaWorkerShutdownTimeoutSeconds();}+ interface OamServiceConfig {+ @WithDefault("true")+ boolean enabled();+ }+interface BcmDataExportsServiceConfig {@WithDefault("true")boolean enabled();diff --git a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.javaindex 9ef752f4b9..bb70d135b9 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java@@ -29,6 +29,7 @@ import io.github.hectorvent.floci.services.lambda.LambdaController;import io.github.hectorvent.floci.services.lambdamicrovms.LambdaMicrovmsController;import io.github.hectorvent.floci.services.lambdamicrovms.LambdaNetworkConnectorsController;import io.github.hectorvent.floci.services.opensearch.OpenSearchController;+import io.github.hectorvent.floci.services.oam.OamController;import io.github.hectorvent.floci.services.cloudfront.CloudFrontController;import io.github.hectorvent.floci.services.cloudfront.CloudFrontServingController;import io.github.hectorvent.floci.services.route53.Route53Controller;@@ -558,6 +559,10 @@ public class ResolvedServiceCatalog {"bcmdataexports", config.storage().mode(), 5000L, null, ServiceProtocol.JSON,protocols(ServiceProtocol.JSON),Set.of("AWSBillingAndCostManagementDataExports."), Set.of("bcm-data-exports"), Set.of(), Set.of()),+ descriptor("oam", "oam", config.services().oam().enabled(), true,+ "oam", config.storage().mode(), 5000L, null, ServiceProtocol.REST_JSON,+ protocols(ServiceProtocol.REST_JSON),+ Set.of(), Set.of("oam"), Set.of(), Set.of(OamController.class)),descriptor("cloudfront", "cloudfront", config.services().cloudfront().enabled(), true,"cloudfront", storageMode(config.storage().services().cloudfront().mode(), config.storage().mode()),5000L, AwsNamespaces.CLOUDFRONT, ServiceProtocol.REST_XML,diff --git a/src/main/java/io/github/hectorvent/floci/services/oam/OamController.java b/src/main/java/io/github/hectorvent/floci/services/oam/OamController.javanew file mode 100644index 0000000000..f9dfdf6126--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/oam/OamController.java@@ -0,0 +1,209 @@+package io.github.hectorvent.floci.services.oam;++import com.fasterxml.jackson.core.type.TypeReference;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.services.oam.model.OamLink;+import io.github.hectorvent.floci.services.oam.model.OamSink;+import jakarta.inject.Inject;+import jakarta.ws.rs.Consumes;+import jakarta.ws.rs.DELETE;+import jakarta.ws.rs.GET;+import jakarta.ws.rs.POST;+import jakarta.ws.rs.PUT;+import jakarta.ws.rs.Path;+import jakarta.ws.rs.PathParam;+import jakarta.ws.rs.Produces;+import jakarta.ws.rs.QueryParam;+import jakarta.ws.rs.core.Context;+import jakarta.ws.rs.core.HttpHeaders;+import jakarta.ws.rs.core.MediaType;+import jakarta.ws.rs.core.Response;++import java.net.URLDecoder;+import java.nio.charset.StandardCharsets;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++@Path("/")+@Produces(MediaType.APPLICATION_JSON)+@Consumes(MediaType.APPLICATION_JSON)+public class OamController {+ private final OamService service;+ private final RegionResolver regionResolver;+ private final ObjectMapper objectMapper;++ @Inject+ public OamController(OamService service, RegionResolver regionResolver, ObjectMapper objectMapper) {+ this.service = service;+ this.regionResolver = regionResolver;+ this.objectMapper = objectMapper;+ }++ @POST @Path("/CreateSink")+ public Response createSink(@Context HttpHeaders headers, Map<String, Object> request) {+ OamSink sink = service.createSink(string(request, "Name"), stringMap(request.get("Tags")), region(headers));+ return Response.ok(sinkBody(sink, true)).build();+ }++ @POST @Path("/GetSink")+ public Response getSink(Map<String, Object> request) {+ OamSink sink = service.getSink(string(request, "Identifier"));+ return Response.ok(sinkBody(sink, boolDefaultTrue(request, "IncludeTags"))).build();+ }++ @POST @Path("/ListSinks")+ public Response listSinks(@Context HttpHeaders headers, Map<String, Object> request) {+ int max = maxResults(request, 100, 100);+ int start = OamService.decodeToken(string(request, "NextToken"));+ List<OamSink> all = service.listSinks(region(headers));+ int end = Math.min(start + max, all.size());+ List<Map<String, Object>> items = all.subList(Math.min(start, all.size()), end).stream()+ .map(s -> Map.<String, Object>of("Arn", s.getArn(), "Id", s.getId(), "Name", s.getName())).toList();+ Map<String, Object> out = new LinkedHashMap<>(); out.put("Items", items);+ if (end < all.size()) out.put("NextToken", OamService.encodeToken(end));+ return Response.ok(out).build();+ }++ @POST @Path("/PutSinkPolicy")+ public Response putSinkPolicy(Map<String, Object> request) {+ String arn = string(request, "SinkIdentifier");+ String policy = string(request, "Policy");+ service.putSinkPolicy(arn, policy);+ OamSink sink = service.getSink(arn);+ return Response.ok(Map.of("Policy", policy, "SinkArn", sink.getArn(), "SinkId", sink.getId())).build();+ }++ @POST @Path("/GetSinkPolicy")+ public Response getSinkPolicy(Map<String, Object> request) {+ OamSink sink = service.getSink(string(request, "SinkIdentifier"));+ Map<String, Object> out = new LinkedHashMap<>();+ if (sink.getPolicy() != null) out.put("Policy", sink.getPolicy());+ out.put("SinkArn", sink.getArn()); out.put("SinkId", sink.getId());+ return Response.ok(out).build();+ }++ @POST @Path("/DeleteSink")+ public Response deleteSink(Map<String, Object> request) {+ service.deleteSink(string(request, "Identifier"));+ return Response.ok(Map.of()).build();+ }++ @POST @Path("/CreateLink")+ public Response createLink(@Context HttpHeaders headers, Map<String, Object> request) {+ OamLink link = service.createLink(string(request, "SinkIdentifier"), string(request, "LabelTemplate"),+ stringList(request.get("ResourceTypes")), objectMap(request.get("LinkConfiguration")),+ stringMap(request.get("Tags")), region(headers));+ return Response.ok(linkBody(link, true)).build();+ }++ @POST @Path("/GetLink")+ public Response getLink(Map<String, Object> request) {+ return Response.ok(linkBody(service.getLink(string(request, "Identifier")), boolDefaultTrue(request, "IncludeTags"))).build();+ }++ @POST @Path("/ListLinks")+ public Response listLinks(@Context HttpHeaders headers, Map<String, Object> request) {+ int max = maxResults(request, 5, 5);+ int start = OamService.decodeToken(string(request, "NextToken"));+ List<OamLink> all = service.listLinks(region(headers));+ int safeStart = Math.min(start, all.size()); int end = Math.min(safeStart + max, all.size());+ List<Map<String, Object>> items = all.subList(safeStart, end).stream().map(this::linkSummary).toList();+ Map<String, Object> out = new LinkedHashMap<>(); out.put("Items", items);+ if (end < all.size()) out.put("NextToken", OamService.encodeToken(end));+ return Response.ok(out).build();+ }++ @POST @Path("/ListAttachedLinks")+ public Response listAttachedLinks(Map<String, Object> request) {+ int max = maxResults(request, 100, 1000);+ int start = OamService.decodeToken(string(request, "NextToken"));+ List<OamLink> all = service.listAttachedLinks(string(request, "SinkIdentifier"));+ int safeStart = Math.min(start, all.size()); int end = Math.min(safeStart + max, all.size());+ List<Map<String, Object>> items = all.subList(safeStart, end).stream().map(link -> Map.<String, Object>of(+ "Label", link.getLabel(), "LinkArn", link.getArn(), "ResourceTypes", link.getResourceTypes())).toList();+ Map<String, Object> out = new LinkedHashMap<>(); out.put("Items", items);+ if (end < all.size()) out.put("NextToken", OamService.encodeToken(end));+ return Response.ok(out).build();+ }++ @POST @Path("/UpdateLink")+ public Response updateLink(Map<String, Object> request) {+ OamLink link = service.updateLink(string(request, "Identifier"), stringList(request.get("ResourceTypes")),+ objectMap(request.get("LinkConfiguration")));+ return Response.ok(linkBody(link, boolDefaultTrue(request, "IncludeTags"))).build();+ }++ @POST @Path("/DeleteLink")+ public Response deleteLink(Map<String, Object> request) {+ service.deleteLink(string(request, "Identifier"));+ return Response.ok(Map.of()).build();+ }++ @GET @Path("/tags/{resourceArn:.+}")+ public Response listTags(@PathParam("resourceArn") String resourceArn) {+ return Response.ok(Map.of("Tags", service.tags(decode(resourceArn)))).build();+ }++ @PUT @Path("/tags/{resourceArn:.+}")+ public Response tag(@PathParam("resourceArn") String resourceArn, Map<String, Object> request) {+ service.tag(decode(resourceArn), stringMap(request.get("Tags")));+ return Response.ok(Map.of()).build();+ }++ @DELETE @Path("/tags/{resourceArn:.+}")+ public Response untag(@PathParam("resourceArn") String resourceArn, @QueryParam("tagKeys") List<String> tagKeys) {+ service.untag(decode(resourceArn), tagKeys);+ return Response.ok(Map.of()).build();+ }++ private Map<String, Object> sinkBody(OamSink sink, boolean includeTags) {+ Map<String, Object> out = new LinkedHashMap<>();+ out.put("Arn", sink.getArn()); out.put("Id", sink.getId()); out.put("Name", sink.getName());+ if (includeTags) out.put("Tags", sink.getTags());+ return out;+ }++ private Map<String, Object> linkBody(OamLink link, boolean includeTags) {+ Map<String, Object> out = linkSummary(link);+ out.put("LabelTemplate", link.getLabelTemplate());+ if (!link.getLinkConfiguration().isEmpty()) out.put("LinkConfiguration", link.getLinkConfiguration());+ if (includeTags) out.put("Tags", link.getTags());+ return out;+ }++ private Map<String, Object> linkSummary(OamLink link) {+ Map<String, Object> out = new LinkedHashMap<>();+ out.put("Arn", link.getArn()); out.put("Id", link.getId()); out.put("Label", link.getLabel());+ out.put("ResourceTypes", link.getResourceTypes()); out.put("SinkArn", link.getSinkArn());+ return out;+ }++ private String region(HttpHeaders headers) { return regionResolver.resolveRegion(headers); }+ private static String decode(String value) { return URLDecoder.decode(value, StandardCharsets.UTF_8); }+ private static String string(Map<String, Object> request, String key) { Object v = request == null ? null : request.get(key); return v == null ? null : String.valueOf(v); }+ private static boolean boolDefaultTrue(Map<String, Object> request, String key) {+ Object value = request == null ? null : request.get(key);+ return value == null || (value instanceof Boolean b ? b : Boolean.parseBoolean(String.valueOf(value)));+ }+ private static int maxResults(Map<String, Object> request, int defaultValue, int max) {+ Object value = request == null ? null : request.get("MaxResults");+ if (value == null) return defaultValue;+ int parsed;+ try { parsed = value instanceof Number n ? n.intValue() : Integer.parseInt(String.valueOf(value)); }+ catch (Exception e) { throw new AwsException("InvalidParameterException", "MaxResults is invalid.", 400); }+ if (parsed < 1 || parsed > max) throw new AwsException("InvalidParameterException", "MaxResults must be between 1 and " + max + ".", 400);+ return parsed;+ }+ @SuppressWarnings("unchecked") private static Map<String, Object> objectMap(Object value) { return value instanceof Map<?, ?> m ? new LinkedHashMap<>((Map<String, Object>) m) : null; }+ @SuppressWarnings("unchecked") private static Map<String, String> stringMap(Object value) {+ if (!(value instanceof Map<?, ?> map)) return null;+ Map<String, String> out = new LinkedHashMap<>(); map.forEach((k, v) -> out.put(String.valueOf(k), v == null ? "" : String.valueOf(v))); return out;+ }+ private static List<String> stringList(Object value) {+ if (!(value instanceof List<?> list)) return null;+ return list.stream().map(String::valueOf).toList();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/oam/OamService.java b/src/main/java/io/github/hectorvent/floci/services/oam/OamService.javanew file mode 100644index 0000000000..6bc8edf72d--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/oam/OamService.java@@ -0,0 +1,387 @@+package io.github.hectorvent.floci.services.oam;++import com.fasterxml.jackson.core.type.TypeReference;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsArnUtils;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.StorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.oam.model.OamLink;+import io.github.hectorvent.floci.services.oam.model.OamSink;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.nio.charset.StandardCharsets;+import java.util.ArrayList;+import java.util.Base64;+import java.util.Collection;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Locale;+import java.util.Map;+import java.util.Set;+import java.util.UUID;+import java.util.regex.Pattern;++@ApplicationScoped+public class OamService {+ private static final Pattern SINK_NAME = Pattern.compile("[A-Za-z0-9_.-]{1,255}");+ private static final Set<String> RESOURCE_TYPES = Set.of(+ "AWS::CloudWatch::Metric", "AWS::Logs::LogGroup", "AWS::XRay::Trace",+ "AWS::ApplicationInsights::Application", "AWS::InternetMonitor::Monitor",+ "AWS::ApplicationSignals::Service", "AWS::ApplicationSignals::ServiceLevelObjective");++ private final StorageBackend<String, OamSink> sinks;+ private final StorageBackend<String, OamLink> links;+ private final RegionResolver regionResolver;+ private final ObjectMapper objectMapper;++ @Inject+ public OamService(StorageFactory storageFactory, RegionResolver regionResolver, ObjectMapper objectMapper) {+ this(storageFactory.create("oam", "oam-sinks.json", new TypeReference<Map<String, OamSink>>() {}),+ storageFactory.create("oam", "oam-links.json", new TypeReference<Map<String, OamLink>>() {}),+ regionResolver, objectMapper);+ }++ OamService(StorageBackend<String, OamSink> sinks, StorageBackend<String, OamLink> links,+ RegionResolver regionResolver, ObjectMapper objectMapper) {+ this.sinks = sinks;+ this.links = links;+ this.regionResolver = regionResolver;+ this.objectMapper = objectMapper;+ }++ public OamSink createSink(String name, Map<String, String> tags, String region) {+ if (name == null) throw missing("Name");+ if (!SINK_NAME.matcher(name).matches()) throw invalid("Name is invalid.");+ validateTags(tags);+ if (!listSinks(region).isEmpty()) {+ throw new AwsException("ConflictException", "A sink already exists in this Region.", 409);+ }+ String id = UUID.randomUUID().toString();+ OamSink sink = new OamSink();+ sink.setId(id);+ sink.setName(name);+ sink.setRegion(region);+ sink.setOwnerAccountId(regionResolver.getAccountId());+ sink.setArn(AwsArnUtils.Arn.of("oam", region, sink.getOwnerAccountId(), "sink/" + id).toString());+ sink.setTags(tags);+ sinks.put(sink.getArn(), sink);+ return sink;+ }++ public OamSink getSink(String identifier) {+ require(identifier, "Identifier");+ return getSinkAcrossAccounts(identifier);+ }++ public List<OamSink> listSinks(String region) {+ return sinks.scan(_ -> true).stream()+ .filter(s -> region.equals(s.getRegion()))+ .sorted(java.util.Comparator.comparing(OamSink::getArn)).toList();+ }++ public void putSinkPolicy(String sinkIdentifier, String policy) {+ require(sinkIdentifier, "SinkIdentifier");+ require(policy, "Policy");+ try {+ JsonNode document = objectMapper.readTree(policy);+ if (!document.isObject() || !document.has("Statement")) throw new IllegalArgumentException();+ } catch (Exception e) {+ throw invalid("Policy must be valid IAM policy JSON.");+ }+ OamSink sink = getOwnedSink(sinkIdentifier);+ sink.setPolicy(policy);+ sinks.put(sink.getArn(), sink);+ }++ public OamLink createLink(String sinkIdentifier, String labelTemplate, List<String> resourceTypes,+ Map<String, Object> linkConfiguration, Map<String, String> tags, String region) {+ require(sinkIdentifier, "SinkIdentifier");+ require(labelTemplate, "LabelTemplate");+ if (labelTemplate.length() > 64) throw invalid("LabelTemplate must be between 1 and 64 characters.");+ validateResourceTypes(resourceTypes);+ validateLinkConfiguration(linkConfiguration);+ validateTags(tags);+ if (listLinks(region).size() >= 5) {+ throw new AwsException("ServiceQuotaExceededException", "A source account can have at most five links.", 429);+ }+ OamSink sink = getSinkAcrossAccounts(sinkIdentifier);+ if (!region.equals(sink.getRegion())) throw invalid("The sink must be in the same Region as the link.");+ authorizeLinkAction(sink, regionResolver.getAccountId(), resourceTypes, "oam:CreateLink");+ boolean duplicate = listLinks(region).stream().anyMatch(l -> sink.getArn().equals(l.getSinkArn()));+ if (duplicate) throw new AwsException("ConflictException", "A link to this sink already exists.", 409);++ String id = UUID.randomUUID().toString();+ OamLink link = new OamLink();+ link.setId(id);+ link.setArn(AwsArnUtils.Arn.of("oam", region, regionResolver.getAccountId(), "link/" + id).toString());+ link.setSourceAccountId(regionResolver.getAccountId());+ link.setRegion(region);+ link.setSinkArn(sink.getArn());+ link.setLabelTemplate(labelTemplate);+ link.setLabel(resolveLabel(labelTemplate, regionResolver.getAccountId()));+ link.setResourceTypes(resourceTypes);+ link.setLinkConfiguration(normalizeConfiguration(linkConfiguration));+ link.setTags(tags);+ links.put(link.getArn(), link);+ return link;+ }++ public OamLink getLink(String identifier) {+ require(identifier, "Identifier");+ return links.get(identifier).orElseThrow(() -> notFound("Link", identifier));+ }++ public List<OamLink> listLinks(String region) {+ return links.scan(_ -> true).stream().filter(l -> region.equals(l.getRegion()))+ .sorted(java.util.Comparator.comparing(OamLink::getArn)).toList();+ }++ public List<OamLink> listAttachedLinks(String sinkIdentifier) {+ OamSink sink = getOwnedSink(sinkIdentifier);+ Collection<OamLink> all;+ if (links instanceof AccountAwareStorageBackend<?> aware) {+ @SuppressWarnings("unchecked")+ AccountAwareStorageBackend<OamLink> typed = (AccountAwareStorageBackend<OamLink>) aware;+ all = typed.scanAllAccounts();+ } else {+ all = links.scan(_ -> true);+ }+ return all.stream().filter(l -> sink.getArn().equals(l.getSinkArn()))+ .sorted(java.util.Comparator.comparing(OamLink::getArn)).toList();+ }++ public OamLink updateLink(String identifier, List<String> resourceTypes,+ Map<String, Object> linkConfiguration) {+ validateResourceTypes(resourceTypes);+ validateLinkConfiguration(linkConfiguration);+ OamLink link = getLink(identifier);+ OamSink sink = getSinkAcrossAccounts(link.getSinkArn());+ authorizeLinkAction(sink, regionResolver.getAccountId(), resourceTypes, "oam:UpdateLink");+ link.setResourceTypes(resourceTypes);+ link.setLinkConfiguration(normalizeConfiguration(linkConfiguration));+ links.put(link.getArn(), link);+ return link;+ }++ public void deleteLink(String identifier) {+ OamLink link = getLink(identifier);+ links.delete(link.getArn());+ }++ public void deleteSink(String identifier) {+ OamSink sink = getOwnedSink(identifier);+ if (!listAttachedLinks(sink.getArn()).isEmpty()) {+ throw new AwsException("ConflictException", "The sink still has attached links.", 409);+ }+ sinks.delete(sink.getArn());+ }++ public Map<String, String> tags(String arn) { return new LinkedHashMap<>(resourceTags(arn)); }++ public void tag(String arn, Map<String, String> tags) {+ validateTags(tags);+ Map<String, String> merged = new LinkedHashMap<>(resourceTags(arn));+ merged.putAll(tags == null ? Map.of() : tags);+ if (merged.size() > 50) throw new AwsException("TooManyTagsException", "A resource can have no more than 50 tags.", 400);+ saveTags(arn, merged);+ }++ public void untag(String arn, List<String> tagKeys) {+ if (tagKeys == null) throw missing("TagKeys");+ Map<String, String> updated = new LinkedHashMap<>(resourceTags(arn));+ tagKeys.forEach(updated::remove);+ saveTags(arn, updated);+ }++ private OamSink getOwnedSink(String identifier) {+ OamSink sink = sinks.get(identifier).orElseThrow(() -> notFound("Sink", identifier));+ if (!regionResolver.getAccountId().equals(sink.getOwnerAccountId())) throw notFound("Sink", identifier);+ return sink;+ }++ private OamSink getSinkAcrossAccounts(String arn) {+ String owner = arnAccount(arn);+ if (owner == null) throw invalid("SinkIdentifier must be a sink ARN.");+ if (sinks instanceof AccountAwareStorageBackend<?> aware) {+ @SuppressWarnings("unchecked")+ AccountAwareStorageBackend<OamSink> typed = (AccountAwareStorageBackend<OamSink>) aware;+ return typed.getForAccount(owner, arn).orElseThrow(() -> notFound("Sink", arn));+ }+ return sinks.get(arn).orElseThrow(() -> notFound("Sink", arn));+ }++ private Map<String, String> resourceTags(String arn) {+ if (arn != null && arn.contains(":sink/")) return getOwnedSink(arn).getTags();+ if (arn != null && arn.contains(":link/")) return getLink(arn).getTags();+ throw notFound("Resource", arn);+ }++ private void saveTags(String arn, Map<String, String> tags) {+ if (arn != null && arn.contains(":sink/")) {+ OamSink sink = getOwnedSink(arn); sink.setTags(tags); sinks.put(arn, sink); return;+ }+ if (arn != null && arn.contains(":link/")) {+ OamLink link = getLink(arn); link.setTags(tags); links.put(arn, link); return;+ }+ throw notFound("Resource", arn);+ }++ private void authorizeLinkAction(OamSink sink, String sourceAccountId, List<String> resourceTypes, String action) {+ if (sink.getPolicy() == null || sink.getPolicy().isBlank()) {+ throw invalid("The sink policy does not allow this source account to perform " + action + ".");+ }+ try {+ JsonNode root = objectMapper.readTree(sink.getPolicy());+ JsonNode statements = root.path("Statement");+ if (!statements.isArray()) statements = objectMapper.createArrayNode().add(statements);+ boolean allowed = false;+ for (JsonNode statement : statements) {+ if (!actionMatches(statement.get("Action"), action)) continue;+ if (!principalMatches(statement.get("Principal"), sourceAccountId)) continue;+ if (!resourceMatches(statement.get("Resource"), sink.getArn())) continue;+ if (!resourceTypeConditionMatches(statement.get("Condition"), resourceTypes)) continue;++ String effect = statement.path("Effect").asText();+ if ("Deny".equalsIgnoreCase(effect)) {+ throw invalid("The sink policy explicitly denies this source account from performing " + action + ".");+ }+ if ("Allow".equalsIgnoreCase(effect)) {+ allowed = true;+ }+ }+ if (!allowed) throw invalid("The sink policy does not allow this source account to perform " + action + ".");+ } catch (AwsException e) {+ throw e;+ } catch (Exception e) {+ throw invalid("The sink policy could not be evaluated.");+ }+ }++ private static boolean actionMatches(JsonNode node, String action) {+ if (node == null) return false;+ if (node.isTextual()) return "*".equals(node.asText()) || action.equalsIgnoreCase(node.asText());+ if (node.isArray()) for (JsonNode n : node) if (actionMatches(n, action)) return true;+ return false;+ }++ private static boolean principalMatches(JsonNode node, String account) {+ if (node == null) return false;+ if (node.isTextual()) return "*".equals(node.asText()) || principalValueMatches(node.asText(), account);+ JsonNode aws = node.path("AWS");+ if (aws.isTextual()) return principalValueMatches(aws.asText(), account);+ if (aws.isArray()) for (JsonNode n : aws) if (principalValueMatches(n.asText(), account)) return true;+ return false;+ }++ private static boolean principalValueMatches(String value, String account) {+ return "*".equals(value) || account.equals(value) || ("arn:aws:iam::" + account + ":root").equals(value);+ }++ private static boolean resourceMatches(JsonNode node, String arn) {+ if (node == null) return true;+ if (node.isTextual()) return "*".equals(node.asText()) || arn.equals(node.asText());+ if (node.isArray()) for (JsonNode n : node) if (resourceMatches(n, arn)) return true;+ return false;+ }++ private static boolean resourceTypeConditionMatches(JsonNode condition, List<String> requested) {+ if (condition == null || condition.isMissingNode() || condition.isNull()) {+ return true;+ }+ List<String> allowed = new ArrayList<>();+ var operators = condition.fields();+ while (operators.hasNext()) {+ Map.Entry<String, JsonNode> operator = operators.next();+ JsonNode entries = operator.getValue();+ if (!entries.isObject()) {+ return false;+ }+ var conditions = entries.fields();+ while (conditions.hasNext()) {+ Map.Entry<String, JsonNode> entry = conditions.next();+ if (!"oam:ResourceTypes".equalsIgnoreCase(entry.getKey())) {+ // Unknown condition keys cannot be safely treated as satisfied. In particular,+ // organization-scoped policies must not degrade into a wildcard allow.+ return false;+ }+ JsonNode values = entry.getValue();+ if (values.isArray()) {+ values.forEach(v -> allowed.add(v.asText()));+ } else {+ allowed.add(values.asText());+ }+ }+ }+ return allowed.isEmpty() || allowed.containsAll(requested);+ }++ private static void validateResourceTypes(List<String> types) {+ if (types == null) throw missing("ResourceTypes");+ if (types.isEmpty() || types.size() > 50 || types.stream().anyMatch(t -> !RESOURCE_TYPES.contains(t))) {+ throw invalid("ResourceTypes contains an unsupported value.");+ }+ }++ private static void validateLinkConfiguration(Map<String, Object> config) {+ if (config == null) return;+ for (String name : List.of("MetricConfiguration", "LogGroupConfiguration")) {+ Object value = config.get(name);+ if (value instanceof Map<?, ?> m && m.containsKey("Filter")) {+ String filter = String.valueOf(m.get("Filter"));+ if (filter.isBlank() || filter.length() > 2000) throw invalid("LinkConfiguration filter is invalid.");+ }+ }+ }++ private static Map<String, Object> normalizeConfiguration(Map<String, Object> config) {+ if (config == null) return Map.of();+ Map<String, Object> out = new LinkedHashMap<>(config);+ out.entrySet().removeIf(e -> e.getValue() instanceof Map<?, ?> m && "*".equals(String.valueOf(m.get("Filter"))));+ return out;+ }++ private static void validateTags(Map<String, String> tags) {+ if (tags == null) return;+ if (tags.size() > 50) throw new AwsException("TooManyTagsException", "A resource can have no more than 50 tags.", 400);+ for (Map.Entry<String, String> e : tags.entrySet()) {+ if (e.getKey() == null || e.getKey().isEmpty() || e.getKey().length() > 128+ || (e.getValue() != null && e.getValue().length() > 256)) {+ throw new AwsException("ValidationException", "Tag key or value is invalid.", 400);+ }+ }+ }++ private static String resolveLabel(String template, String account) {+ return template.replace("$AccountName", account).replace("$AccountEmailNoDomain", account)+ .replace("$AccountEmail", account);+ }++ private static String arnAccount(String arn) {+ try { return AwsArnUtils.parse(arn).accountId(); } catch (Exception e) { return null; }+ }++ public static String encodeToken(int offset) {+ return Base64.getUrlEncoder().withoutPadding().encodeToString(String.valueOf(offset).getBytes(StandardCharsets.UTF_8));+ }++ public static int decodeToken(String token) {+ if (token == null || token.isBlank()) return 0;+ try {+ int offset = Integer.parseInt(new String(Base64.getUrlDecoder().decode(token), StandardCharsets.UTF_8));+ if (offset < 0) throw new NumberFormatException();+ return offset;+ } catch (Exception e) {+ throw invalid("NextToken is invalid.");+ }+ }++ private static void require(String value, String field) { if (value == null || value.isBlank()) throw missing(field); }+ private static AwsException missing(String field) { return new AwsException("MissingRequiredParameterException", "Missing required parameter: " + field, 400); }+ private static AwsException invalid(String message) { return new AwsException("InvalidParameterException", message, 400); }+ private static AwsException notFound(String type, String id) { return new AwsException("ResourceNotFoundException", type + " " + id + " not found.", 404); }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/oam/model/OamLink.java b/src/main/java/io/github/hectorvent/floci/services/oam/model/OamLink.javanew file mode 100644index 0000000000..664c02edd4--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/oam/model/OamLink.java@@ -0,0 +1,44 @@+package io.github.hectorvent.floci.services.oam.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++@RegisterForReflection+public class OamLink {+ private String arn;+ private String id;+ private String label;+ private String labelTemplate;+ private String sinkArn;+ private String region;+ private String sourceAccountId;+ private List<String> resourceTypes = List.of();+ private Map<String, Object> linkConfiguration = new LinkedHashMap<>();+ private Map<String, String> tags = new LinkedHashMap<>();++ public OamLink() {}++ public String getArn() { return arn; }+ public void setArn(String arn) { this.arn = arn; }+ public String getId() { return id; }+ public void setId(String id) { this.id = id; }+ public String getLabel() { return label; }+ public void setLabel(String label) { this.label = label; }+ public String getLabelTemplate() { return labelTemplate; }+ public void setLabelTemplate(String labelTemplate) { this.labelTemplate = labelTemplate; }+ public String getSinkArn() { return sinkArn; }+ public void setSinkArn(String sinkArn) { this.sinkArn = sinkArn; }+ public String getRegion() { return region; }+ public void setRegion(String region) { this.region = region; }+ public String getSourceAccountId() { return sourceAccountId; }+ public void setSourceAccountId(String sourceAccountId) { this.sourceAccountId = sourceAccountId; }+ public List<String> getResourceTypes() { return resourceTypes; }+ public void setResourceTypes(List<String> resourceTypes) { this.resourceTypes = resourceTypes == null ? List.of() : List.copyOf(resourceTypes); }+ public Map<String, Object> getLinkConfiguration() { return linkConfiguration; }+ public void setLinkConfiguration(Map<String, Object> linkConfiguration) { this.linkConfiguration = linkConfiguration == null ? new LinkedHashMap<>() : new LinkedHashMap<>(linkConfiguration); }+ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) { this.tags = tags == null ? new LinkedHashMap<>() : new LinkedHashMap<>(tags); }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/oam/model/OamSink.java b/src/main/java/io/github/hectorvent/floci/services/oam/model/OamSink.javanew file mode 100644index 0000000000..36fa73c8bb--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/oam/model/OamSink.java@@ -0,0 +1,34 @@+package io.github.hectorvent.floci.services.oam.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.LinkedHashMap;+import java.util.Map;++@RegisterForReflection+public class OamSink {+ private String arn;+ private String id;+ private String name;+ private String region;+ private String ownerAccountId;+ private String policy;+ private Map<String, String> tags = new LinkedHashMap<>();++ public OamSink() {}++ public String getArn() { return arn; }+ public void setArn(String arn) { this.arn = arn; }+ public String getId() { return id; }+ public void setId(String id) { this.id = id; }+ public String getName() { return name; }+ public void setName(String name) { this.name = name; }+ public String getRegion() { return region; }+ public void setRegion(String region) { this.region = region; }+ public String getOwnerAccountId() { return ownerAccountId; }+ public void setOwnerAccountId(String ownerAccountId) { this.ownerAccountId = ownerAccountId; }+ public String getPolicy() { return policy; }+ public void setPolicy(String policy) { this.policy = policy; }+ public Map<String, String> getTags() { return tags; }+ public void setTags(Map<String, String> tags) { this.tags = tags == null ? new LinkedHashMap<>() : new LinkedHashMap<>(tags); }+}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex a8227e5af3..13be06c3cc 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -605,6 +605,8 @@ floci:bcm-data-exports:enabled: trueemit-mode: synchronous+ oam:+ enabled: truecloudtrail:enabled: truelightsail:diff --git a/src/test/java/io/github/hectorvent/floci/services/oam/OamIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/oam/OamIntegrationTest.javanew file mode 100644index 0000000000..375d94cbf4--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/oam/OamIntegrationTest.java@@ -0,0 +1,168 @@+package io.github.hectorvent.floci.services.oam;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.*;++@QuarkusTest+class OamIntegrationTest {++ private static final String MONITORING =+ "AWS4-HMAC-SHA256 Credential=111111111111/20260911/us-east-1/oam/aws4_request";+ private static final String SOURCE =+ "AWS4-HMAC-SHA256 Credential=222222222222/20260911/us-east-1/oam/aws4_request";++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ void sinkLinkLifecycleWorksAcrossAccounts() {+ String sinkArn = given()+ .header("Authorization", MONITORING)+ .contentType("application/json")+ .body("{\"Name\":\"central-observability\"}")+ .when().post("/CreateSink")+ .then().statusCode(200)+ .body("Name", equalTo("central-observability"))+ .body("Arn", startsWith("arn:aws:oam:us-east-1:111111111111:sink/"))+ .extract().path("Arn");++ String policy = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\","+ + "\"Principal\":{\"AWS\":\"arn:aws:iam::222222222222:root\"},"+ + "\"Action\":[\"oam:CreateLink\",\"oam:UpdateLink\"],\"Resource\":\"" + sinkArn + "\","+ + "\"Condition\":{\"ForAllValues:StringEquals\":{\"oam:ResourceTypes\":["+ + "\"AWS::CloudWatch::Metric\",\"AWS::Logs::LogGroup\"]}}}]}";++ given().header("Authorization", MONITORING).contentType("application/json")+ .body(java.util.Map.of("SinkIdentifier", sinkArn, "Policy", policy))+ .when().post("/PutSinkPolicy")+ .then().statusCode(200).body("SinkArn", equalTo(sinkArn));++ String linkArn = given().header("Authorization", SOURCE).contentType("application/json")+ .body(java.util.Map.of(+ "SinkIdentifier", sinkArn,+ "LabelTemplate", "source-account",+ "ResourceTypes", java.util.List.of("AWS::CloudWatch::Metric")))+ .when().post("/CreateLink")+ .then().statusCode(200)+ .body("SinkArn", equalTo(sinkArn))+ .body("ResourceTypes", contains("AWS::CloudWatch::Metric"))+ .extract().path("Arn");++ given().header("Authorization", SOURCE).contentType("application/json").body("{}")+ .when().post("/ListLinks")+ .then().statusCode(200).body("Items.Arn", contains(linkArn));++ given().header("Authorization", MONITORING).contentType("application/json")+ .body(java.util.Map.of("SinkIdentifier", sinkArn))+ .when().post("/ListAttachedLinks")+ .then().statusCode(200).body("Items.LinkArn", contains(linkArn));++ given().header("Authorization", SOURCE).contentType("application/json")+ .body(java.util.Map.of(+ "Identifier", linkArn,+ "ResourceTypes", java.util.List.of("AWS::CloudWatch::Metric", "AWS::Logs::LogGroup"),+ "LinkConfiguration", java.util.Map.of(+ "MetricConfiguration", java.util.Map.of("Filter", "Namespace LIKE 'AWS/%'"))))+ .when().post("/UpdateLink")+ .then().statusCode(200)+ .body("ResourceTypes.size()", equalTo(2))+ .body("LinkConfiguration.MetricConfiguration.Filter", equalTo("Namespace LIKE 'AWS/%'"));++ given().header("Authorization", SOURCE).contentType("application/json")+ .body(java.util.Map.of("Identifier", linkArn))+ .when().post("/DeleteLink")+ .then().statusCode(200);++ given().header("Authorization", MONITORING).contentType("application/json")+ .body(java.util.Map.of("Identifier", sinkArn))+ .when().post("/DeleteSink")+ .then().statusCode(200);+ }++ @Test+ void sinkPolicyRejectsUnauthorizedSourceAccount() {+ String sinkArn = given().header("Authorization", MONITORING).contentType("application/json")+ .body("{\"Name\":\"policy-test\"}")+ .when().post("/CreateSink")+ .then().statusCode(200).extract().path("Arn");++ String policy = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\","+ + "\"Principal\":{\"AWS\":\"arn:aws:iam::333333333333:root\"},"+ + "\"Action\":\"oam:CreateLink\",\"Resource\":\"*\"}]}";+ given().header("Authorization", MONITORING).contentType("application/json")+ .body(java.util.Map.of("SinkIdentifier", sinkArn, "Policy", policy))+ .when().post("/PutSinkPolicy")+ .then().statusCode(200);++ given().header("Authorization", SOURCE).contentType("application/json")+ .body(java.util.Map.of(+ "SinkIdentifier", sinkArn,+ "LabelTemplate", "denied",+ "ResourceTypes", java.util.List.of("AWS::CloudWatch::Metric")))+ .when().post("/CreateLink")+ .then().statusCode(400).body("__type", containsString("InvalidParameterException"));++ given().header("Authorization", MONITORING).contentType("application/json")+ .body(java.util.Map.of("Identifier", sinkArn))+ .when().post("/DeleteSink")+ .then().statusCode(200);+ }+ @Test+ void unsupportedOrganizationConditionDoesNotBecomeWildcardAllow() {+ String sinkArn = given().header("Authorization", MONITORING).contentType("application/json")+ .body("{\"Name\":\"org-policy-test\"}")+ .when().post("/CreateSink")+ .then().statusCode(200).extract().path("Arn");++ String policy = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\","+ + "\"Principal\":\"*\",\"Action\":\"oam:CreateLink\",\"Resource\":\"*\","+ + "\"Condition\":{\"StringEquals\":{\"aws:PrincipalOrgID\":\"o-example\"}}}]}";+ given().header("Authorization", MONITORING).contentType("application/json")+ .body(java.util.Map.of("SinkIdentifier", sinkArn, "Policy", policy))+ .when().post("/PutSinkPolicy").then().statusCode(200);++ given().header("Authorization", SOURCE).contentType("application/json")+ .body(java.util.Map.of("SinkIdentifier", sinkArn, "LabelTemplate", "source",+ "ResourceTypes", java.util.List.of("AWS::CloudWatch::Metric")))+ .when().post("/CreateLink")+ .then().statusCode(400).body("__type", containsString("InvalidParameterException"));++ given().header("Authorization", MONITORING).contentType("application/json")+ .body(java.util.Map.of("Identifier", sinkArn))+ .when().post("/DeleteSink").then().statusCode(200);+ }++ @Test+ void explicitDenyOverridesMatchingAllow() {+ String sinkArn = given().header("Authorization", MONITORING).contentType("application/json")+ .body("{\"Name\":\"explicit-deny-test\"}")+ .when().post("/CreateSink")+ .then().statusCode(200).extract().path("Arn");++ String policy = "{\"Version\":\"2012-10-17\",\"Statement\":["+ + "{\"Effect\":\"Allow\",\"Principal\":\"*\",\"Action\":\"oam:CreateLink\",\"Resource\":\"*\"},"+ + "{\"Effect\":\"Deny\",\"Principal\":{\"AWS\":\"arn:aws:iam::222222222222:root\"},"+ + "\"Action\":\"oam:CreateLink\",\"Resource\":\"*\"}]}";+ given().header("Authorization", MONITORING).contentType("application/json")+ .body(java.util.Map.of("SinkIdentifier", sinkArn, "Policy", policy))+ .when().post("/PutSinkPolicy").then().statusCode(200);++ given().header("Authorization", SOURCE).contentType("application/json")+ .body(java.util.Map.of("SinkIdentifier", sinkArn, "LabelTemplate", "source",+ "ResourceTypes", java.util.List.of("AWS::CloudWatch::Metric")))+ .when().post("/CreateLink")+ .then().statusCode(400).body("__type", containsString("InvalidParameterException"));++ given().header("Authorization", MONITORING).contentType("application/json")+ .body(java.util.Map.of("Identifier", sinkArn))+ .when().post("/DeleteSink").then().statusCode(200);+ }++}diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex 418d3f6e0f..45c5e51678 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -342,6 +342,8 @@ floci:bcm-data-exports:enabled: trueemit-mode: off+ oam:+ enabled: truecloudtrail:enabled: trueflush-interval-seconds: 3600