Light, fluffy, and always free - The AWS Local Emulator alternative
feat(codeartifact): add CodeArtifact control-plane support (#3713)
Priamo Germosen66bcdaf6750e
diff --git a/README.md b/README.mdindex 5ac3bcc57b..bf5f6355c0 100644--- a/README.md+++ b/README.md@@ -295,7 +295,7 @@ Floci supports local emulation for application services, data services, eventing| Core app services | S3, SQS, SNS, DynamoDB, Lambda, Lambda MicroVMs, IAM, STS, KMS, Secrets Manager, SSM || 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, Cognito Identity, 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 |+| Containers and compute | ECS, EC2, Lightsail, EKS, MWAA, ECR, EFS, CodeBuild, CodeDeploy, CodePipeline, CodeGuru Reviewer, CodeArtifact, 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, Bedrock AgentCore Control, SageMaker || Databases and caching | RDS, RDS Data API, Neptune, DocumentDB, MemoryDB, ElastiCache || Messaging and transfer | SES, Kinesis, MSK, Amazon MQ, Transfer Family, DataSync, IoT Core, Amazon Connect, Amazon AppIntegrations |diff --git a/compatibility-tests/compat-terraform/test/codeartifact-domain-repo-tf/main.tf b/compatibility-tests/compat-terraform/test/codeartifact-domain-repo-tf/main.tfnew file mode 100644index 0000000000..dcac4d45de--- /dev/null+++ b/compatibility-tests/compat-terraform/test/codeartifact-domain-repo-tf/main.tf@@ -0,0 +1,84 @@+# Verifies the CodeArtifact control plane: domain/repository CRUD, tags, upstream repositories,+# and resource policies, all of which previously had no Floci support at all.++resource "aws_codeartifact_domain" "test" {+ domain = "floci-codeartifact-domain"++ tags = {+ owner = "platform"+ }+}++data "aws_iam_policy_document" "domain_policy" {+ statement {+ effect = "Allow"+ actions = ["codeartifact:GetDomainPermissions"]+ resources = [aws_codeartifact_domain.test.arn]+ principals {+ type = "AWS"+ identifiers = ["*"]+ }+ }+}++resource "aws_codeartifact_domain_permissions_policy" "test" {+ domain = aws_codeartifact_domain.test.domain+ policy_document = data.aws_iam_policy_document.domain_policy.json+}++resource "aws_codeartifact_repository" "store" {+ domain = aws_codeartifact_domain.test.domain+ repository = "floci-codeartifact-store"+}++resource "aws_codeartifact_repository" "consumer" {+ domain = aws_codeartifact_domain.test.domain+ repository = "floci-codeartifact-consumer"+ description = "consumes packages via the store repository"++ upstream {+ repository_name = aws_codeartifact_repository.store.repository+ }++ tags = {+ team = "data"+ }+}++data "aws_iam_policy_document" "repository_policy" {+ statement {+ effect = "Allow"+ actions = ["codeartifact:ReadFromRepository"]+ resources = [aws_codeartifact_repository.consumer.arn]+ principals {+ type = "AWS"+ identifiers = ["*"]+ }+ }+}++resource "aws_codeartifact_repository_permissions_policy" "test" {+ domain = aws_codeartifact_domain.test.domain+ repository = aws_codeartifact_repository.consumer.repository+ policy_document = data.aws_iam_policy_document.repository_policy.json+}++output "domain_arn" {+ value = aws_codeartifact_domain.test.arn+}++output "domain_owner_tag" {+ value = aws_codeartifact_domain.test.tags["owner"]+}++output "repository_arn" {+ value = aws_codeartifact_repository.consumer.arn+}++output "repository_upstream" {+ value = aws_codeartifact_repository.consumer.upstream[0].repository_name+}++output "repository_team_tag" {+ value = aws_codeartifact_repository.consumer.tags["team"]+}diff --git a/compatibility-tests/compat-terraform/test/codeartifact-domain-repo-tf/provider.tf b/compatibility-tests/compat-terraform/test/codeartifact-domain-repo-tf/provider.tfnew file mode 100644index 0000000000..3d4014b7ff--- /dev/null+++ b/compatibility-tests/compat-terraform/test/codeartifact-domain-repo-tf/provider.tf@@ -0,0 +1,28 @@+terraform {+ required_providers {+ aws = {+ source = "hashicorp/aws"+ version = "~> 6.0"+ }+ }+}++variable "endpoint" {+ type = string+ default = "http://localhost:4566"+}++provider "aws" {+ region = "us-east-1"+ access_key = "test"+ secret_key = "test"++ skip_credentials_validation = true+ skip_metadata_api_check = true+ skip_requesting_account_id = true+ s3_use_path_style = true++ endpoints {+ codeartifact = var.endpoint+ }+}diff --git a/compatibility-tests/compat-terraform/test/codeartifact_domain_repo.bats b/compatibility-tests/compat-terraform/test/codeartifact_domain_repo.batsnew file mode 100644index 0000000000..8053dc9e2c--- /dev/null+++ b/compatibility-tests/compat-terraform/test/codeartifact_domain_repo.bats@@ -0,0 +1,88 @@+#!/usr/bin/env bats+# CodeArtifact Control Plane Compatibility Test+#+# Floci previously had no CodeArtifact support at all. This verifies aws_codeartifact_domain,+# aws_codeartifact_domain_permissions_policy, aws_codeartifact_repository (with tags and an+# upstream), and aws_codeartifact_repository_permissions_policy can all apply, that a second+# plan is clean, and that destroy tears everything down in dependency order.++setup_file() {+ load 'test_helper/common-setup'++ CA_TF_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/codeartifact-domain-repo-tf" && pwd)"+ cd "$CA_TF_DIR"++ echo "# === CodeArtifact Domain/Repository Test ===" >&3+ echo "# Endpoint: $FLOCI_ENDPOINT" >&3+ echo "# Config: $CA_TF_DIR" >&3++ find .terraform -mindepth 1 -delete 2>/dev/null || true+ rm -f .terraform.lock.hcl terraform.tfstate terraform.tfstate.backup 2>/dev/null || true++ echo "# --- terraform init ---" >&3+ run terraform init -input=false -no-color+ if [ "$status" -ne 0 ]; then+ echo "# terraform init failed: $output" >&3+ return 1+ fi++ echo "# --- terraform apply ---" >&3+ run terraform apply -var="endpoint=${FLOCI_ENDPOINT}" -input=false -auto-approve -no-color+ if [ "$status" -ne 0 ]; then+ echo "# terraform apply failed: $output" >&3+ return 1+ fi+}++teardown_file() {+ load 'test_helper/common-setup'++ CA_TF_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/codeartifact-domain-repo-tf" && pwd)"+ cd "$CA_TF_DIR"++ terraform destroy -var="endpoint=${FLOCI_ENDPOINT}" -input=false -auto-approve -no-color || true+ find .terraform -mindepth 1 -delete 2>/dev/null || true+ rm -f .terraform.lock.hcl terraform.tfstate terraform.tfstate.backup 2>/dev/null || true+}++setup() {+ load 'test_helper/common-setup'+ CA_TF_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/codeartifact-domain-repo-tf" && pwd)"+}++@test "CodeArtifact domain/repository: apply reports the domain and repository ARNs" {+ DOMAIN_ARN=$(terraform -chdir="$CA_TF_DIR" output -raw domain_arn)+ REPO_ARN=$(terraform -chdir="$CA_TF_DIR" output -raw repository_arn)+ assert_equal "$DOMAIN_ARN" "arn:aws:codeartifact:us-east-1:000000000000:domain/floci-codeartifact-domain"+ assert_equal "$REPO_ARN" "arn:aws:codeartifact:us-east-1:000000000000:repository/floci-codeartifact-domain/floci-codeartifact-consumer"+}++@test "CodeArtifact domain/repository: tags and upstream round-trip" {+ OWNER_TAG=$(terraform -chdir="$CA_TF_DIR" output -raw domain_owner_tag)+ TEAM_TAG=$(terraform -chdir="$CA_TF_DIR" output -raw repository_team_tag)+ UPSTREAM=$(terraform -chdir="$CA_TF_DIR" output -raw repository_upstream)+ assert_equal "$OWNER_TAG" "platform"+ assert_equal "$TEAM_TAG" "data"+ assert_equal "$UPSTREAM" "floci-codeartifact-store"+}++@test "CodeArtifact domain/repository: DescribeDomain reports the live repository count" {+ run aws_cmd codeartifact describe-domain --domain floci-codeartifact-domain \+ --query "domain.repositoryCount" --output text+ assert_success+ assert_output "2"+}++@test "CodeArtifact domain/repository: second plan reports no changes" {+ cd "$CA_TF_DIR"+ run terraform plan -var="endpoint=${FLOCI_ENDPOINT}" -input=false -no-color -detailed-exitcode+ assert_success+ assert_output --partial "No changes"+}++@test "CodeArtifact domain/repository: GetRepositoryEndpoint resolves for a real package format" {+ run aws_cmd codeartifact get-repository-endpoint --domain floci-codeartifact-domain \+ --repository floci-codeartifact-consumer --format npm --query repositoryEndpoint --output text+ assert_success+ [[ "$output" == *"/codeartifact/npm/floci-codeartifact-domain/floci-codeartifact-consumer/"* ]]+}diff --git a/compatibility-tests/sdk-test-java/pom.xml b/compatibility-tests/sdk-test-java/pom.xmlindex 6da7b1e750..cb72711cfe 100644--- a/compatibility-tests/sdk-test-java/pom.xml+++ b/compatibility-tests/sdk-test-java/pom.xml@@ -376,6 +376,11 @@<groupId>software.amazon.awssdk</groupId><artifactId>guardduty</artifactId></dependency>+ <!-- CodeArtifact client -->+ <dependency>+ <groupId>software.amazon.awssdk</groupId>+ <artifactId>codeartifact</artifactId>+ </dependency><!-- AWS Resource Access Manager client --><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 1ba7a77a0d..77b364a2df 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@@ -11,6 +11,7 @@ import software.amazon.awssdk.services.cloudfront.CloudFrontClient;import software.amazon.awssdk.services.cloudtrail.CloudTrailClient;import software.amazon.awssdk.services.cloudwatch.CloudWatchClient;import software.amazon.awssdk.services.cloudwatchlogs.CloudWatchLogsClient;+import software.amazon.awssdk.services.codeartifact.CodeartifactClient;import software.amazon.awssdk.services.cognitoidentityprovider.CognitoIdentityProviderClient;import software.amazon.awssdk.services.dynamodb.DynamoDbClient;import software.amazon.awssdk.core.client.config.SdkAdvancedClientOption;@@ -1059,6 +1060,14 @@ public final class TestFixtures {.build();}+ public static CodeartifactClient codeArtifactClient() {+ return CodeartifactClient.builder()+ .endpointOverride(ENDPOINT)+ .region(REGION)+ .credentialsProvider(CREDENTIALS)+ .build();+ }+public static NeptuneClient neptuneClient() {return NeptuneClient.builder().endpointOverride(ENDPOINT)diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CodeArtifactTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CodeArtifactTest.javanew file mode 100644index 0000000000..4771494786--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CodeArtifactTest.java@@ -0,0 +1,229 @@+package com.floci.test;++import org.jboss.logging.Logger;+import org.junit.jupiter.api.*;+import software.amazon.awssdk.services.codeartifact.CodeartifactClient;+import software.amazon.awssdk.services.codeartifact.model.*;+// Explicit import: this file's Tag usage is the CodeArtifact model type, not JUnit's @Tag.+import software.amazon.awssdk.services.codeartifact.model.Tag;++import java.util.List;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++@DisplayName("CodeArtifact")+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class CodeArtifactTest {++ private static final Logger LOG = Logger.getLogger(CodeArtifactTest.class);++ private static CodeartifactClient codeArtifact;++ private static final String DOMAIN = "compat-test-domain";+ private static final String STORE_REPO = "compat-test-store";+ private static final String REPO = "compat-test-repo";++ private static String domainArn;+ private static String repositoryArn;++ @BeforeAll+ static void setup() {+ codeArtifact = TestFixtures.codeArtifactClient();+ }++ @AfterAll+ static void cleanup() {+ if (codeArtifact == null) return;+ try {+ codeArtifact.deleteRepository(r -> r.domain(DOMAIN).repository(REPO));+ } catch (Exception e) {+ LOG.warnf(e, "Failed to delete repository %s during test cleanup", REPO);+ }+ try {+ codeArtifact.deleteRepository(r -> r.domain(DOMAIN).repository(STORE_REPO));+ } catch (Exception e) {+ LOG.warnf(e, "Failed to delete repository %s during test cleanup", STORE_REPO);+ }+ try {+ codeArtifact.deleteDomain(r -> r.domain(DOMAIN));+ } catch (Exception e) {+ LOG.warnf(e, "Failed to delete domain %s during test cleanup", DOMAIN);+ }+ codeArtifact.close();+ }++ @Test+ @Order(10)+ @DisplayName("CreateDomain - creates a domain with tags")+ void createDomain() {+ CreateDomainResponse resp = codeArtifact.createDomain(r -> r+ .domain(DOMAIN)+ .tags(Tag.builder().key("owner").value("platform").build()));++ domainArn = resp.domain().arn();+ assertThat(resp.domain().name()).isEqualTo(DOMAIN);+ assertThat(domainArn).contains("domain/" + DOMAIN);+ assertThat(resp.domain().status()).isEqualTo(DomainStatus.ACTIVE);+ assertThat(resp.domain().repositoryCount()).isZero();+ }++ @Test+ @Order(11)+ @DisplayName("CreateDomain - duplicate returns ConflictException")+ void createDomainDuplicateFails() {+ assertThatThrownBy(() -> codeArtifact.createDomain(r -> r.domain(DOMAIN)))+ .isInstanceOf(ConflictException.class);+ }++ @Test+ @Order(20)+ @DisplayName("CreateRepository - fails against a domain that does not exist")+ void createRepositoryMissingDomainFails() {+ assertThatThrownBy(() -> codeArtifact.createRepository(r -> r+ .domain("does-not-exist-domain")+ .repository(REPO)))+ .isInstanceOf(ResourceNotFoundException.class);+ }++ @Test+ @Order(21)+ @DisplayName("CreateRepository - creates the upstream store repository")+ void createStoreRepository() {+ CreateRepositoryResponse resp = codeArtifact.createRepository(r -> r+ .domain(DOMAIN)+ .repository(STORE_REPO));++ assertThat(resp.repository().name()).isEqualTo(STORE_REPO);+ assertThat(resp.repository().upstreams()).isEmpty();+ }++ @Test+ @Order(22)+ @DisplayName("CreateRepository - creates a repository with an upstream and tags")+ void createRepository() {+ CreateRepositoryResponse resp = codeArtifact.createRepository(r -> r+ .domain(DOMAIN)+ .repository(REPO)+ .description("compat test repo")+ .upstreams(UpstreamRepository.builder().repositoryName(STORE_REPO).build())+ .tags(Tag.builder().key("team").value("data").build()));++ repositoryArn = resp.repository().arn();+ assertThat(resp.repository().domainName()).isEqualTo(DOMAIN);+ assertThat(resp.repository().upstreams()).hasSize(1);+ assertThat(resp.repository().upstreams().get(0).repositoryName()).isEqualTo(STORE_REPO);+ }++ @Test+ @Order(23)+ @DisplayName("DescribeDomain - reports the live repository count")+ void describeDomainReportsRepositoryCount() {+ DescribeDomainResponse resp = codeArtifact.describeDomain(r -> r.domain(DOMAIN));+ assertThat(resp.domain().repositoryCount()).isEqualTo(2);+ }++ @Test+ @Order(30)+ @DisplayName("TagResource / ListTagsForResource / UntagResource round-trip on the repository")+ void tagRoundTrip() {+ codeArtifact.tagResource(r -> r+ .resourceArn(repositoryArn)+ .tags(Tag.builder().key("env").value("compat").build()));++ List<Tag> tags = codeArtifact.listTagsForResource(r -> r.resourceArn(repositoryArn)).tags();+ assertThat(tags).extracting(Tag::key).contains("team", "env");++ codeArtifact.untagResource(r -> r.resourceArn(repositoryArn).tagKeys("env"));+ tags = codeArtifact.listTagsForResource(r -> r.resourceArn(repositoryArn)).tags();+ assertThat(tags).extracting(Tag::key).doesNotContain("env");+ }++ @Test+ @Order(31)+ @DisplayName("TagResource / ListTagsForResource round-trip on the domain")+ void tagRoundTripOnDomain() {+ codeArtifact.tagResource(r -> r+ .resourceArn(domainArn)+ .tags(Tag.builder().key("cost-center").value("platform-eng").build()));++ List<Tag> tags = codeArtifact.listTagsForResource(r -> r.resourceArn(domainArn)).tags();+ assertThat(tags).extracting(Tag::key).contains("owner", "cost-center");+ }++ @Test+ @Order(40)+ @DisplayName("GetRepositoryEndpoint - resolves for a real package format")+ void getRepositoryEndpoint() {+ GetRepositoryEndpointResponse resp = codeArtifact.getRepositoryEndpoint(r -> r+ .domain(DOMAIN)+ .repository(REPO)+ .format(PackageFormat.NPM));++ assertThat(resp.repositoryEndpoint()).contains("/codeartifact/npm/" + DOMAIN + "/" + REPO + "/");+ }++ @Test+ @Order(50)+ @DisplayName("Repository permissions policy - put/get/delete with optimistic locking")+ void repositoryPermissionsPolicyRoundTrip() {+ String policyDocument = "{\"Version\":\"2012-10-17\",\"Statement\":[]}";+ PutRepositoryPermissionsPolicyResponse put = codeArtifact.putRepositoryPermissionsPolicy(r -> r+ .domain(DOMAIN)+ .repository(REPO)+ .policyDocument(policyDocument));++ assertThat(put.policy().document()).isEqualTo(policyDocument);++ assertThatThrownBy(() -> codeArtifact.putRepositoryPermissionsPolicy(r -> r+ .domain(DOMAIN)+ .repository(REPO)+ .policyDocument(policyDocument)+ .policyRevision("not-the-current-revision")))+ .isInstanceOf(ConflictException.class);++ GetRepositoryPermissionsPolicyResponse got = codeArtifact.getRepositoryPermissionsPolicy(r -> r+ .domain(DOMAIN)+ .repository(REPO));+ assertThat(got.policy().revision()).isEqualTo(put.policy().revision());++ codeArtifact.deleteRepositoryPermissionsPolicy(r -> r.domain(DOMAIN).repository(REPO));+ assertThatThrownBy(() -> codeArtifact.getRepositoryPermissionsPolicy(r -> r+ .domain(DOMAIN)+ .repository(REPO)))+ .isInstanceOf(ResourceNotFoundException.class);+ }++ @Test+ @Order(60)+ @DisplayName("AssociateExternalConnection - accepts a real AWS-hosted public upstream")+ void externalConnectionRoundTrip() {+ AssociateExternalConnectionResponse assoc = codeArtifact.associateExternalConnection(r -> r+ .domain(DOMAIN)+ .repository(STORE_REPO)+ .externalConnection("public:npmjs"));++ assertThat(assoc.repository().externalConnections()).hasSize(1);+ assertThat(assoc.repository().externalConnections().get(0).packageFormat()).isEqualTo(PackageFormat.NPM);++ assertThatThrownBy(() -> codeArtifact.associateExternalConnection(r -> r+ .domain(DOMAIN)+ .repository(STORE_REPO)+ .externalConnection("public:pypi")))+ .isInstanceOf(ConflictException.class);++ DisassociateExternalConnectionResponse disassoc = codeArtifact.disassociateExternalConnection(r -> r+ .domain(DOMAIN)+ .repository(STORE_REPO)+ .externalConnection("public:npmjs"));+ assertThat(disassoc.repository().externalConnections()).isEmpty();+ }++ @Test+ @Order(90)+ @DisplayName("DeleteDomain - fails while repositories still exist")+ void deleteDomainWithRepositoriesFails() {+ assertThatThrownBy(() -> codeArtifact.deleteDomain(r -> r.domain(DOMAIN)))+ .isInstanceOf(ConflictException.class);+ }+}diff --git a/docs/services/codeartifact.md b/docs/services/codeartifact.mdnew file mode 100644index 0000000000..f786cd3895--- /dev/null+++ b/docs/services/codeartifact.md@@ -0,0 +1,81 @@+# CodeArtifact++**Protocol:** REST JSON++**Endpoint:** `http://localhost:4566`++Floci supports the CodeArtifact control plane: domains, repositories, resource policies, tags,+and public upstream (external) connections. Package publish/fetch endpoints for each format+(npm, PyPI, Maven, NuGet, generic, etc.) are not implemented yet.++## Supported Actions++<!-- floci:actions:start -->+| Action | Description |+| --- | --- |+| `CreateDomain` | Creates a domain, optionally with a KMS encryption key and initial tags. |+| `DeleteDomain` | Deletes a domain; fails with `ConflictException` while it still contains repositories. |+| `DescribeDomain` | Returns a domain's full description, including its repository count. |+| `ListDomains` | Lists domain summaries for the account and Region, paginated. |+| `PutDomainPermissionsPolicy` | Attaches or replaces a domain's resource policy, versioned by `policyRevision`. |+| `GetDomainPermissionsPolicy` | Returns a domain's current resource policy and revision. |+| `DeleteDomainPermissionsPolicy` | Removes a domain's resource policy, optionally checked against `policyRevision`. |+| `CreateRepository` | Creates a repository with optional description, upstreams (max 10), and tags. |+| `DeleteRepository` | Deletes a repository. |+| `DescribeRepository` | Returns a repository's full description, including upstreams and external connections. |+| `UpdateRepository` | Updates a repository's description and/or upstream list. |+| `ListRepositories` | Lists repository summaries across all domains, optionally filtered by name prefix. |+| `ListRepositoriesInDomain` | Lists repository summaries within one domain, optionally filtered by name prefix. |+| `GetRepositoryEndpoint` | Returns the package-format-specific endpoint URL for a repository. |+| `PutRepositoryPermissionsPolicy` | Attaches or replaces a repository's resource policy, versioned by `policyRevision`. |+| `GetRepositoryPermissionsPolicy` | Returns a repository's current resource policy and revision. |+| `DeleteRepositoryPermissionsPolicy` | Removes a repository's resource policy, optionally checked against `policyRevision`. |+| `AssociateExternalConnection` | Attaches a fixed-catalog public upstream (e.g. `public:npmjs`) to a repository; mutually exclusive with repository upstreams. |+| `DisassociateExternalConnection` | Removes a repository's external connection. |+| `TagResource` | Adds or updates tags on a domain or repository ARN. |+| `UntagResource` | Removes tags by key from a domain or repository ARN. |+| `ListTagsForResource` | Lists the tags on a domain or repository ARN. |+<!-- floci:actions:end -->++Domains and repositories are account and Region scoped and persisted through `StorageFactory`.+`DeleteDomain` fails with `ConflictException` while the domain still contains repositories, matching+AWS. `PutDomainPermissionsPolicy`/`PutRepositoryPermissionsPolicy` use the returned `policyRevision`+for optimistic locking on subsequent updates, also matching AWS.++`AssociateExternalConnection` accepts the same fixed set of AWS-hosted public upstreams+documented for real CodeArtifact (`public:npmjs`, `public:pypi`, `public:maven-central`, etc.) and+enforces the one-external-connection-per-repository limit AWS enforces. A repository can have+upstream repositories or an external connection, but not both, matching AWS; `CreateRepository`+and `UpdateRepository` also cap direct upstreams at 10, AWS's own repository limit.++## AWS-compatible failures++Domain and repository names, tags, pagination, duplicate names, missing upstreams, policy-revision+mismatches, and non-empty-domain deletes are validated. Floci returns `ValidationException`,+`ConflictException`, `ResourceNotFoundException`, and `ServiceQuotaExceededException` (tag limits)+for deterministic conditions represented by local state.++AWS also models `AccessDeniedException`, `InternalServerException`, and `ThrottlingException`.+Floci does not inject provider-side failures that cannot be derived from the request or emulator+state.++## Known limitations++- **Upstream cycles are not rejected.** `CreateRepository`/`UpdateRepository` reject a repository+ naming itself as its own upstream and require each named upstream to already exist, but a longer+ cycle (repository A has B as an upstream, B has A) is not detected.+- **`DeleteRepository` does not check whether other repositories still reference it as an+ upstream.** Deleting a repository leaves any repository that named it as an upstream pointing at+ one that no longer exists.+- **Cross-account `domainOwner` addressing has no authorization check.** Passing a `domainOwner`+ that is not the caller's own account looks up that account's domain/repository with no+ trust-policy or permissions-policy enforcement, consistent with Floci's IAM enforcement being+ opt-in elsewhere, but worth knowing if you rely on domain-sharing semantics.++See the [CodeArtifact API Reference](https://docs.aws.amazon.com/codeartifact/latest/APIReference/Welcome.html).++## Configuration++| Variable | Default | Description |+|---|---|---|+| `FLOCI_SERVICES_CODEARTIFACT_ENABLED` | `true` | Enable or disable CodeArtifact |diff --git a/docs/services/index.md b/docs/services/index.mdindex 557a92c61f..2e4091a2e2 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -117,6 +117,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [AWS Backup](backup.md) | `/backup-vaults/*`, `/backup/plans/*`, `/backup-jobs/*`, `/supported-resource-types` | REST JSON | 20 || [AWS FIS](fis.md) | `/experimentTemplates/*`, `/experiments/*`, `/actions/*`, `/targetResourceTypes/*`, `/safetyLevers/*`, `/tags/*` | REST JSON | 26 || [CodeGuru Reviewer](codegurureviewer.md) | `/associations`, `/associations/{associationArn}`, `/tags/*` | REST JSON | 7 |+| [CodeArtifact](codeartifact.md) | `/v1/domain*`, `/v1/repository*`, `/v1/tag*` | REST JSON | 22 || [CloudFront](cloudfront.md) | `/2020-05-31/distribution/*`, `/2020-05-31/cache-policy/*`, `/2020-05-31/function/*` | REST XML | 50 || [Route53](route53.md) | `/2013-04-01/hostedzone/*`, `/2013-04-01/healthcheck/*`, `/2013-04-01/change/*` | REST XML | 25 || [Route 53 Resolver](route53resolver.md) | `POST /` + `X-Amz-Target: Route53Resolver.*` | JSON 1.1 | 18 |diff --git a/mkdocs.yml b/mkdocs.ymlindex 4e7a6be03c..d1683979a0 100644--- a/mkdocs.yml+++ b/mkdocs.yml@@ -184,6 +184,7 @@ nav:- SageMaker: services/sagemaker.md- CodeDeploy: services/codedeploy.md- CodeGuru Reviewer: services/codegurureviewer.md+ - CodeArtifact: services/codeartifact.md- CodePipeline: services/codepipeline.md- Service Quotas: services/servicequotas.md- AWS RAM: services/ram.mddiff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 945a8e86d6..c238cd78d6 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -789,9 +789,15 @@ public interface EmulatorConfig {LakeFormationServiceConfig lakeformation();EfsServiceConfig efs();CodeGuruReviewerServiceConfig codegurureviewer();+ CodeArtifactServiceConfig codeartifact();MarketplaceServiceConfig marketplace();}+ interface CodeArtifactServiceConfig {+ @WithDefault("true")+ boolean enabled();+ }+interface ConnectServiceConfig {@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 40b71fb2ed..e4bf5ff6a7 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@@ -709,6 +709,11 @@ public class ResolvedServiceCatalog {protocols(ServiceProtocol.REST_JSON),Set.of(), Set.of("codeguru-reviewer"), Set.of(),Set.of(io.github.hectorvent.floci.services.codegurureviewer.CodeGuruReviewerController.class)),+ descriptor("codeartifact", "codeartifact", config.services().codeartifact().enabled(), true,+ "codeartifact", config.storage().mode(), 5000L, null, ServiceProtocol.REST_JSON,+ protocols(ServiceProtocol.REST_JSON),+ Set.of(), Set.of("codeartifact"), Set.of(),+ Set.of(io.github.hectorvent.floci.services.codeartifact.CodeArtifactController.class)),descriptor("verifiedpermissions", "verifiedpermissions", config.services().verifiedpermissions().enabled(), true,"verifiedpermissions", config.storage().mode(), 5000L, null, ServiceProtocol.JSON,protocols(ServiceProtocol.JSON),diff --git a/src/main/java/io/github/hectorvent/floci/core/common/TagDispatcher.java b/src/main/java/io/github/hectorvent/floci/core/common/TagDispatcher.javaindex ef77592139..6065628e9a 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/TagDispatcher.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/TagDispatcher.java@@ -113,8 +113,8 @@ public class TagDispatcher {ArrayNode arr = root.putArray(key);tags.forEach((k, v) -> {ObjectNode entry = arr.addObject();- entry.put("Key", k);- entry.put("Value", v);+ entry.put(handler.tagEntryKeyName(), k);+ entry.put(handler.tagEntryValueName(), v);});} else {ObjectNode tagsNode = root.putObject(key);@@ -147,8 +147,8 @@ public class TagDispatcher {return tags;}for (JsonNode entry : tagNode) {- JsonNode k = entry.get("Key");- JsonNode v = entry.get("Value");+ JsonNode k = entry.get(handler.tagEntryKeyName());+ JsonNode v = entry.get(handler.tagEntryValueName());if (k == null || k.isNull() || v == null || v.isNull()) {if (handler.strictTagValidation()) {throw new AwsException("ValidationException",diff --git a/src/main/java/io/github/hectorvent/floci/core/common/TagHandler.java b/src/main/java/io/github/hectorvent/floci/core/common/TagHandler.javaindex fb9c80223e..69f559e71d 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/TagHandler.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/TagHandler.java@@ -106,6 +106,24 @@ public interface TagHandler {return false;}+ /**+ * JSON member name for a tag entry's key when {@link #tagsBodyIsList()} is {@code true}.+ * Defaults to {@code "Key"}, matching the great majority of list-shaped AWS services.+ * Override to {@code "key"} for services that lowercase entry members (CodeArtifact).+ */+ default String tagEntryKeyName() {+ return "Key";+ }++ /**+ * JSON member name for a tag entry's value when {@link #tagsBodyIsList()} is {@code true}.+ * Defaults to {@code "Value"}, matching the great majority of list-shaped AWS services.+ * Override to {@code "value"} for services that lowercase entry members (CodeArtifact).+ */+ default String tagEntryValueName() {+ return "Value";+ }+/** HTTP status for successful path-based TagResource requests. */default int tagResourceSuccessStatus() {return 204;diff --git a/src/main/java/io/github/hectorvent/floci/core/common/V1TagsController.java b/src/main/java/io/github/hectorvent/floci/core/common/V1TagsController.javaindex d5a06d6f13..4ccd0bea1c 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/V1TagsController.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/V1TagsController.java@@ -3,13 +3,20 @@ package io.github.hectorvent.floci.core.common;import com.fasterxml.jackson.databind.ObjectMapper;import jakarta.enterprise.inject.Instance;import jakarta.inject.Inject;+import jakarta.ws.rs.Consumes;+import jakarta.ws.rs.POST;import jakarta.ws.rs.Path;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;/*** Dispatcher for the AWS services that put their tag endpoints on {@code /v1/tags/{resourceArn}}- * (AppSync, MSK).+ * (AppSync, MSK) or, for CodeArtifact, on the bare {@code /v1/tags} path with {@code resourceArn}+ * as a query parameter.** <p>Same problem and same resolution as {@link SharedTagsController}, one path up: AWS tells* these services apart by hostname, floci serves them all on one port, so the owning service is@@ -26,4 +33,20 @@ public class V1TagsController extends AbstractTagsController {ObjectMapper objectMapper) {super(new TagDispatcher(handlers, regionResolver, objectMapper));}++ /**+ * {@code ListTagsForResource} for services that address the resource with a query+ * parameter on the bare path ({@code POST /v1/tags?resourceArn=...}) rather than a path+ * segment. CodeArtifact is the only registered handler on this shape today.+ *+ * <p>This lives here rather than on {@link AbstractTagsController} because+ * {@link SharedTagsController} already declares its own bare {@code POST} ({@code+ * tagResourceByBody}), and a bare {@code POST} on the shared base would collide with it.+ */+ @POST+ @Consumes(MediaType.APPLICATION_JSON)+ public Response listTagsForResourceByQuery(@Context HttpHeaders headers,+ @QueryParam("resourceArn") String resourceArn) {+ return dispatcher().listTagsForArn(headers, resourceArn);+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.javanew file mode 100644index 0000000000..204457d4f3--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.java@@ -0,0 +1,437 @@+package io.github.hectorvent.floci.services.codeartifact;++import com.fasterxml.jackson.databind.DeserializationFeature;+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.core.common.JsonErrorResponseUtils;+import io.github.hectorvent.floci.core.common.PaginatedResult;+import io.github.hectorvent.floci.core.common.Pagination;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.DomainView;+import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.ResourcePolicy;+import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactRepository;+import io.github.hectorvent.floci.services.codeartifact.model.ExternalConnection;+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.Produces;+import jakarta.ws.rs.QueryParam;+import jakarta.ws.rs.WebApplicationException;+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.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++@Path("/")+@Produces(MediaType.APPLICATION_JSON)+@Consumes(MediaType.APPLICATION_JSON)+public class CodeArtifactController {++ private final CodeArtifactService service;+ private final RegionResolver regionResolver;+ private final ObjectMapper objectMapper;++ @Inject+ public CodeArtifactController(CodeArtifactService service, RegionResolver regionResolver,+ ObjectMapper objectMapper) {+ this.service = service;+ this.regionResolver = regionResolver;+ this.objectMapper = objectMapper;+ }++ // ---------------------------------------------------------------- domains++ @POST+ @Path("/v1/domain")+ public Response createDomain(@Context HttpHeaders headers, @QueryParam("domain") String domain, String body) {+ JsonNode req = readTree(body);+ String region = regionResolver.resolveRegion(headers);+ DomainView view = service.createDomain(region, domain, text(req, "encryptionKey"), readTagList(req.get("tags")));+ return ok(single("domain", domainDescription(view)));+ }++ @DELETE+ @Path("/v1/domain")+ public Response deleteDomain(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner) {+ String region = regionResolver.resolveRegion(headers);+ DomainView view = service.deleteDomain(region, domain, domainOwner);+ return ok(single("domain", domainDescription(view)));+ }++ @GET+ @Path("/v1/domain")+ public Response describeDomain(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner) {+ String region = regionResolver.resolveRegion(headers);+ DomainView view = service.describeDomain(region, domain, domainOwner);+ return ok(single("domain", domainDescription(view)));+ }++ @POST+ @Path("/v1/domains")+ public Response listDomains(@Context HttpHeaders headers, String body) {+ JsonNode req = readTree(body);+ String region = regionResolver.resolveRegion(headers);+ Integer maxResults = req.hasNonNull("maxResults") ? req.get("maxResults").asInt() : null;+ PaginatedResult<DomainView> page = service.listDomains(region, maxResults, text(req, "nextToken"));+ ObjectNode response = objectMapper.createObjectNode();+ ArrayNode items = response.putArray("domains");+ page.items().forEach(view -> items.add(domainSummary(view)));+ if (page.nextToken() != null) {+ response.put("nextToken", page.nextToken());+ }+ return ok(response);+ }++ @PUT+ @Path("/v1/domain/permissions/policy")+ public Response putDomainPermissionsPolicy(@Context HttpHeaders headers, String body) {+ JsonNode req = readTree(body);+ String region = regionResolver.resolveRegion(headers);+ ResourcePolicy policy = service.putDomainPermissionsPolicy(region, text(req, "domain"),+ text(req, "domainOwner"), text(req, "policyDocument"), text(req, "policyRevision"));+ return ok(single("policy", resourcePolicy(policy)));+ }++ @GET+ @Path("/v1/domain/permissions/policy")+ public Response getDomainPermissionsPolicy(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner) {+ String region = regionResolver.resolveRegion(headers);+ ResourcePolicy policy = service.getDomainPermissionsPolicy(region, domain, domainOwner);+ return ok(single("policy", resourcePolicy(policy)));+ }++ @DELETE+ @Path("/v1/domain/permissions/policy")+ public Response deleteDomainPermissionsPolicy(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("policy-revision") String policyRevision) {+ String region = regionResolver.resolveRegion(headers);+ ResourcePolicy policy = service.deleteDomainPermissionsPolicy(region, domain, domainOwner, policyRevision);+ return ok(single("policy", resourcePolicy(policy)));+ }++ // ------------------------------------------------------------ repositories++ @POST+ @Path("/v1/repository")+ public Response createRepository(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("repository") String repository, String body) {+ JsonNode req = readTree(body);+ String region = regionResolver.resolveRegion(headers);+ CodeArtifactRepository r = service.createRepository(region, domain, domainOwner, repository,+ text(req, "description"), readUpstreams(req.get("upstreams")), readTagList(req.get("tags")));+ return ok(single("repository", repositoryDescription(r)));+ }++ @DELETE+ @Path("/v1/repository")+ public Response deleteRepository(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("repository") String repository) {+ String region = regionResolver.resolveRegion(headers);+ CodeArtifactRepository r = service.deleteRepository(region, domain, domainOwner, repository);+ return ok(single("repository", repositoryDescription(r)));+ }++ @GET+ @Path("/v1/repository")+ public Response describeRepository(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("repository") String repository) {+ String region = regionResolver.resolveRegion(headers);+ CodeArtifactRepository r = service.describeRepository(region, domain, domainOwner, repository);+ return ok(single("repository", repositoryDescription(r)));+ }++ @PUT+ @Path("/v1/repository")+ public Response updateRepository(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("repository") String repository, String body) {+ JsonNode req = readTree(body);+ String region = regionResolver.resolveRegion(headers);+ CodeArtifactRepository r = service.updateRepository(region, domain, domainOwner, repository,+ text(req, "description"), req.has("upstreams") ? readUpstreams(req.get("upstreams")) : null);+ return ok(single("repository", repositoryDescription(r)));+ }++ @POST+ @Path("/v1/repositories")+ public Response listRepositories(@Context HttpHeaders headers,+ @QueryParam("repository-prefix") String repositoryPrefix,+ @QueryParam("max-results") String maxResults,+ @QueryParam("next-token") String nextToken) {+ String region = regionResolver.resolveRegion(headers);+ PaginatedResult<CodeArtifactRepository> page = service.listRepositories(region, repositoryPrefix,+ Pagination.parseMaxResults(maxResults, "ValidationException"), nextToken);+ return ok(repositorySummaryList(page));+ }++ @POST+ @Path("/v1/domain/repositories")+ public Response listRepositoriesInDomain(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("administrator-account") String administratorAccount,+ @QueryParam("repository-prefix") String repositoryPrefix,+ @QueryParam("max-results") String maxResults,+ @QueryParam("next-token") String nextToken) {+ String region = regionResolver.resolveRegion(headers);+ PaginatedResult<CodeArtifactRepository> page = service.listRepositoriesInDomain(region, domain, domainOwner,+ administratorAccount, repositoryPrefix, Pagination.parseMaxResults(maxResults, "ValidationException"),+ nextToken);+ return ok(repositorySummaryList(page));+ }++ @GET+ @Path("/v1/repository/endpoint")+ public Response getRepositoryEndpoint(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("repository") String repository,+ @QueryParam("format") String format,+ @QueryParam("endpointType") String endpointType) {+ String region = regionResolver.resolveRegion(headers);+ String endpoint = service.getRepositoryEndpoint(region, domain, domainOwner, repository, format,+ endpointType);+ ObjectNode response = objectMapper.createObjectNode();+ response.put("repositoryEndpoint", endpoint);+ return ok(response);+ }++ @PUT+ @Path("/v1/repository/permissions/policy")+ public Response putRepositoryPermissionsPolicy(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("repository") String repository, String body) {+ JsonNode req = readTree(body);+ String region = regionResolver.resolveRegion(headers);+ ResourcePolicy policy = service.putRepositoryPermissionsPolicy(region, domain, domainOwner, repository,+ text(req, "policyDocument"), text(req, "policyRevision"));+ return ok(single("policy", resourcePolicy(policy)));+ }++ @GET+ @Path("/v1/repository/permissions/policy")+ public Response getRepositoryPermissionsPolicy(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("repository") String repository) {+ String region = regionResolver.resolveRegion(headers);+ ResourcePolicy policy = service.getRepositoryPermissionsPolicy(region, domain, domainOwner, repository);+ return ok(single("policy", resourcePolicy(policy)));+ }++ @DELETE+ @Path("/v1/repository/permissions/policies")+ public Response deleteRepositoryPermissionsPolicy(@Context HttpHeaders headers,+ @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("repository") String repository,+ @QueryParam("policy-revision") String policyRevision) {+ String region = regionResolver.resolveRegion(headers);+ ResourcePolicy policy = service.deleteRepositoryPermissionsPolicy(region, domain, domainOwner, repository,+ policyRevision);+ return ok(single("policy", resourcePolicy(policy)));+ }++ @POST+ @Path("/v1/repository/external-connection")+ public Response associateExternalConnection(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("repository") String repository,+ @QueryParam("external-connection") String externalConnection) {+ String region = regionResolver.resolveRegion(headers);+ CodeArtifactRepository r = service.associateExternalConnection(region, domain, domainOwner, repository,+ externalConnection);+ return ok(single("repository", repositoryDescription(r)));+ }++ @DELETE+ @Path("/v1/repository/external-connection")+ public Response disassociateExternalConnection(@Context HttpHeaders headers, @QueryParam("domain") String domain,+ @QueryParam("domain-owner") String domainOwner,+ @QueryParam("repository") String repository,+ @QueryParam("external-connection") String externalConnection) {+ String region = regionResolver.resolveRegion(headers);+ CodeArtifactRepository r = service.disassociateExternalConnection(region, domain, domainOwner, repository,+ externalConnection);+ return ok(single("repository", repositoryDescription(r)));+ }++ // -------------------------------------------------------------------- tags++ @POST+ @Path("/v1/tag")+ public Response tagResource(@QueryParam("resourceArn") String resourceArn, String body) {+ JsonNode req = readTree(body);+ service.tagResource(resourceArn, readTagList(req.get("tags")));+ return ok(objectMapper.createObjectNode());+ }++ @POST+ @Path("/v1/untag")+ public Response untagResource(@QueryParam("resourceArn") String resourceArn, String body) {+ JsonNode req = readTree(body);+ List<String> keys = new ArrayList<>();+ if (req.hasNonNull("tagKeys") && req.get("tagKeys").isArray()) {+ req.get("tagKeys").forEach(n -> keys.add(n.asText()));+ }+ service.untagResource(resourceArn, keys);+ return ok(objectMapper.createObjectNode());+ }++ // ListTagsForResource (POST /v1/tags?resourceArn=) is handled by V1TagsController via+ // CodeArtifactTagHandler; see their javadoc.++ // ----------------------------------------------------------------- helpers++ private ObjectNode domainDescription(DomainView view) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("arn", view.domain().getArn());+ node.put("assetSizeBytes", 0L);+ node.put("createdTime", view.domain().getCreatedTime());+ node.put("encryptionKey", view.domain().getEncryptionKey());+ node.put("name", view.domain().getName());+ node.put("owner", view.domain().getOwner());+ node.put("repositoryCount", view.repositoryCount());+ // AWS's internal per-domain bucket naming is not publicly documented; this is a synthesized placeholder.+ node.put("s3BucketArn", "arn:aws:s3:::codeartifact-" + view.domain().getRegion() + "-" + view.domain().getOwner());+ node.put("status", "Active");+ return node;+ }++ private ObjectNode domainSummary(DomainView view) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("name", view.domain().getName());+ node.put("owner", view.domain().getOwner());+ node.put("arn", view.domain().getArn());+ node.put("status", "Active");+ node.put("createdTime", view.domain().getCreatedTime());+ node.put("encryptionKey", view.domain().getEncryptionKey());+ return node;+ }++ private ObjectNode repositoryDescription(CodeArtifactRepository r) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("administratorAccount", r.getAdministratorAccount());+ node.put("arn", r.getArn());+ node.put("createdTime", r.getCreatedTime());+ if (r.getDescription() != null) {+ node.put("description", r.getDescription());+ }+ node.put("domainName", r.getDomainName());+ node.put("domainOwner", r.getDomainOwner());+ ArrayNode connections = node.putArray("externalConnections");+ for (ExternalConnection ec : r.getExternalConnections()) {+ ObjectNode c = objectMapper.createObjectNode();+ c.put("externalConnectionName", ec.getExternalConnectionName());+ c.put("packageFormat", ec.getPackageFormat());+ c.put("status", ec.getStatus());+ connections.add(c);+ }+ node.put("name", r.getName());+ ArrayNode upstreams = node.putArray("upstreams");+ for (String upstream : r.getUpstreams()) {+ ObjectNode u = objectMapper.createObjectNode();+ u.put("repositoryName", upstream);+ upstreams.add(u);+ }+ return node;+ }++ private ObjectNode repositorySummary(CodeArtifactRepository r) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("name", r.getName());+ node.put("administratorAccount", r.getAdministratorAccount());+ node.put("domainName", r.getDomainName());+ node.put("domainOwner", r.getDomainOwner());+ node.put("arn", r.getArn());+ if (r.getDescription() != null) {+ node.put("description", r.getDescription());+ }+ node.put("createdTime", r.getCreatedTime());+ return node;+ }++ private ObjectNode repositorySummaryList(PaginatedResult<CodeArtifactRepository> page) {+ ObjectNode response = objectMapper.createObjectNode();+ ArrayNode items = response.putArray("repositories");+ page.items().forEach(r -> items.add(repositorySummary(r)));+ if (page.nextToken() != null) {+ response.put("nextToken", page.nextToken());+ }+ return response;+ }++ private ObjectNode resourcePolicy(ResourcePolicy policy) {+ ObjectNode node = objectMapper.createObjectNode();+ node.put("resourceArn", policy.resourceArn());+ node.put("revision", policy.revision());+ node.put("document", policy.document());+ return node;+ }++ private ObjectNode single(String field, ObjectNode value) {+ ObjectNode wrapper = objectMapper.createObjectNode();+ wrapper.set(field, value);+ return wrapper;+ }++ private Response ok(ObjectNode body) {+ return Response.ok(body).build();+ }++ private Map<String, String> readTagList(JsonNode tagsArray) {+ Map<String, String> tags = new LinkedHashMap<>();+ if (tagsArray == null || tagsArray.isNull()) {+ return tags;+ }+ if (!tagsArray.isArray()) {+ throw new AwsException("ValidationException", "tags must be an array of {key, value} objects.", 400);+ }+ tagsArray.forEach(n -> tags.put(text(n, "key"), text(n, "value")));+ return tags;+ }++ private List<String> readUpstreams(JsonNode upstreamsArray) {+ List<String> upstreams = new ArrayList<>();+ if (upstreamsArray == null || upstreamsArray.isNull()) {+ return upstreams;+ }+ if (!upstreamsArray.isArray()) {+ throw new AwsException("ValidationException", "upstreams must be an array of {repositoryName} objects.",+ 400);+ }+ upstreamsArray.forEach(n -> upstreams.add(text(n, "repositoryName")));+ return upstreams;+ }++ private static String text(JsonNode node, String field) {+ JsonNode value = node == null ? null : node.get(field);+ return value != null && value.isTextual() ? value.textValue() : null;+ }++ private JsonNode readTree(String body) {+ try {+ return objectMapper.reader()+ .with(DeserializationFeature.FAIL_ON_TRAILING_TOKENS)+ .readTree(body == null || body.isBlank() ? "{}" : body);+ } catch (Exception e) {+ throw new WebApplicationException(JsonErrorResponseUtils.createSerializationErrorResponse());+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.javanew file mode 100644index 0000000000..9887efa1bf--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.java@@ -0,0 +1,544 @@+package io.github.hectorvent.floci.services.codeartifact;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsArnUtils;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.PaginatedResult;+import io.github.hectorvent.floci.core.common.Pagination;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.Resettable;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactDomain;+import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactRepository;+import io.github.hectorvent.floci.services.codeartifact.model.ExternalConnection;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.time.Instant;+import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.Optional;+import java.util.Set;+import java.util.UUID;+import java.util.regex.Pattern;++@ApplicationScoped+public class CodeArtifactService implements Resettable {++ /** name -> packageFormat, the fixed real set of AWS-hosted public upstream connections. */+ private static final Map<String, String> EXTERNAL_CONNECTIONS = Map.ofEntries(+ Map.entry("public:maven-clojars", "maven"),+ Map.entry("public:maven-commonsware", "maven"),+ Map.entry("public:maven-googleandroid", "maven"),+ Map.entry("public:maven-gradleplugins", "maven"),+ Map.entry("public:maven-central", "maven"),+ Map.entry("public:npmjs", "npm"),+ Map.entry("public:nuget-org", "nuget"),+ Map.entry("public:pypi", "pypi"),+ Map.entry("public:ruby-gems-org", "ruby"),+ Map.entry("public:crates-io", "cargo"));++ private static final Set<String> PACKAGE_FORMATS =+ Set.of("npm", "pypi", "maven", "nuget", "generic", "ruby", "swift", "cargo");+ private static final Set<String> ENDPOINT_TYPES = Set.of("dualstack", "ipv4");++ private static final Pattern DOMAIN_NAME = Pattern.compile("[a-z][a-z0-9\\-]{0,48}[a-z0-9]");+ private static final Pattern REPOSITORY_NAME = Pattern.compile("[A-Za-z0-9][A-Za-z0-9._\\-]{1,99}");+ private static final Pattern ACCOUNT_ID = Pattern.compile("[0-9]{12}");++ public record DomainView(CodeArtifactDomain domain, int repositoryCount) {}+ public record ResourcePolicy(String resourceArn, String revision, String document) {}++ private final AccountAwareStorageBackend<CodeArtifactDomain> domains;+ private final AccountAwareStorageBackend<CodeArtifactRepository> repositories;+ private final RegionResolver regionResolver;+ private final EmulatorConfig config;++ @Inject+ public CodeArtifactService(StorageFactory storageFactory, RegionResolver regionResolver, EmulatorConfig config) {+ this.domains = storageFactory.create("codeartifact", "codeartifact-domains.json",+ new TypeReference<Map<String, CodeArtifactDomain>>() {});+ this.repositories = storageFactory.create("codeartifact", "codeartifact-repositories.json",+ new TypeReference<Map<String, CodeArtifactRepository>>() {});+ this.regionResolver = regionResolver;+ this.config = config;+ }++ // ---------------------------------------------------------------- domains++ public synchronized DomainView createDomain(String region, String domain, String encryptionKey,+ Map<String, String> tags) {+ validateDomainName(domain);+ String owner = regionResolver.getAccountId();+ String key = domainKey(region, domain);+ if (domains.getForAccount(owner, key).isPresent()) {+ throw conflict("Domain with name '" + domain + "' already exists.");+ }+ CodeArtifactDomain d = new CodeArtifactDomain();+ d.setName(domain);+ d.setOwner(owner);+ d.setRegion(region);+ d.setArn(regionResolver.buildArn("codeartifact", region, "domain/" + domain));+ d.setEncryptionKey(encryptionKey != null ? encryptionKey+ : regionResolver.buildArn("kms", region, "alias/aws/codeartifact"));+ d.setCreatedTime(Instant.now().getEpochSecond());+ d.setTags(validateTags(tags, Map.of()));+ domains.putForAccount(owner, key, d);+ return new DomainView(d, 0);+ }++ public synchronized DomainView deleteDomain(String region, String domain, String domainOwner) {+ String owner = effectiveOwner(domainOwner);+ String key = domainKey(region, domain);+ CodeArtifactDomain d = requireDomain(owner, key);+ int repoCount = repositoryCountForDomain(owner, region, domain);+ if (repoCount > 0) {+ throw conflict("Domain '" + domain + "' contains repositories and cannot be deleted "+ + "until they are deleted.");+ }+ domains.deleteForAccount(owner, key);+ return new DomainView(d, 0);+ }++ public DomainView describeDomain(String region, String domain, String domainOwner) {+ String owner = effectiveOwner(domainOwner);+ CodeArtifactDomain d = requireDomain(owner, domainKey(region, domain));+ return new DomainView(d, repositoryCountForDomain(owner, region, domain));+ }++ public PaginatedResult<DomainView> listDomains(String region, Integer maxResults, String nextToken) {+ String owner = regionResolver.getAccountId();+ List<CodeArtifactDomain> matching = domains.scanForAccount(owner, k -> k.startsWith(region + "::"));+ PaginatedResult<CodeArtifactDomain> page = Pagination.paginate(matching, CodeArtifactDomain::getName,+ maxResults, nextToken, 100, 1000, "ValidationException");+ List<DomainView> views = page.items().stream()+ .map(d -> new DomainView(d, repositoryCountForDomain(owner, region, d.getName())))+ .toList();+ return new PaginatedResult<>(views, page.nextToken());+ }++ public synchronized ResourcePolicy putDomainPermissionsPolicy(String region, String domain, String domainOwner,+ String policyDocument, String policyRevision) {+ String owner = effectiveOwner(domainOwner);+ String key = domainKey(region, domain);+ CodeArtifactDomain d = requireDomain(owner, key);+ checkRevision(d.getPolicyRevision(), policyRevision);+ validatePolicyDocument(policyDocument);+ d.setPolicyDocument(policyDocument);+ d.setPolicyRevision(newRevision());+ domains.putForAccount(owner, key, d);+ return new ResourcePolicy(d.getArn(), d.getPolicyRevision(), d.getPolicyDocument());+ }++ public ResourcePolicy getDomainPermissionsPolicy(String region, String domain, String domainOwner) {+ String owner = effectiveOwner(domainOwner);+ CodeArtifactDomain d = requireDomain(owner, domainKey(region, domain));+ if (d.getPolicyDocument() == null) {+ throw notFound("No resource policy is associated with domain '" + domain + "'.");+ }+ return new ResourcePolicy(d.getArn(), d.getPolicyRevision(), d.getPolicyDocument());+ }++ public synchronized ResourcePolicy deleteDomainPermissionsPolicy(String region, String domain, String domainOwner,+ String policyRevision) {+ String owner = effectiveOwner(domainOwner);+ String key = domainKey(region, domain);+ CodeArtifactDomain d = requireDomain(owner, key);+ if (d.getPolicyDocument() == null) {+ throw notFound("No resource policy is associated with domain '" + domain + "'.");+ }+ checkRevision(d.getPolicyRevision(), policyRevision);+ ResourcePolicy removed = new ResourcePolicy(d.getArn(), d.getPolicyRevision(), d.getPolicyDocument());+ d.setPolicyDocument(null);+ d.setPolicyRevision(null);+ domains.putForAccount(owner, key, d);+ return removed;+ }++ // ------------------------------------------------------------ repositories++ public synchronized CodeArtifactRepository createRepository(String region, String domain, String domainOwner,+ String repository, String description,+ List<String> upstreams, Map<String, String> tags) {+ validateRepositoryName(repository);+ String owner = effectiveOwner(domainOwner);+ requireDomain(owner, domainKey(region, domain));+ String key = repositoryKey(region, domain, repository);+ if (repositories.getForAccount(owner, key).isPresent()) {+ throw conflict("Repository with name '" + repository + "' already exists in domain '" + domain + "'.");+ }+ validateUpstreams(owner, region, domain, repository, upstreams);+ validateDescription(description);++ CodeArtifactRepository r = new CodeArtifactRepository();+ r.setName(repository);+ r.setDomainName(domain);+ r.setDomainOwner(owner);+ r.setAdministratorAccount(regionResolver.getAccountId());+ r.setRegion(region);+ r.setArn(regionResolver.buildArn("codeartifact", region, "repository/" + domain + "/" + repository));+ r.setDescription(description);+ r.setUpstreams(upstreams != null ? new ArrayList<>(upstreams) : new ArrayList<>());+ r.setCreatedTime(Instant.now().getEpochSecond());+ r.setTags(validateTags(tags, Map.of()));+ repositories.putForAccount(owner, key, r);+ return r;+ }++ public synchronized CodeArtifactRepository deleteRepository(String region, String domain, String domainOwner,+ String repository) {+ String owner = effectiveOwner(domainOwner);+ String key = repositoryKey(region, domain, repository);+ CodeArtifactRepository r = requireRepository(owner, key);+ repositories.deleteForAccount(owner, key);+ return r;+ }++ public CodeArtifactRepository describeRepository(String region, String domain, String domainOwner,+ String repository) {+ String owner = effectiveOwner(domainOwner);+ return requireRepository(owner, repositoryKey(region, domain, repository));+ }++ public synchronized CodeArtifactRepository updateRepository(String region, String domain, String domainOwner,+ String repository, String description,+ List<String> upstreams) {+ String owner = effectiveOwner(domainOwner);+ String key = repositoryKey(region, domain, repository);+ CodeArtifactRepository r = requireRepository(owner, key);+ if (upstreams != null) {+ if (!upstreams.isEmpty() && !r.getExternalConnections().isEmpty()) {+ throw conflict("Repository '" + repository + "' has an external connection; "+ + "a repository cannot have both an external connection and upstream repositories.");+ }+ validateUpstreams(owner, region, domain, repository, upstreams);+ r.setUpstreams(new ArrayList<>(upstreams));+ }+ if (description != null) {+ validateDescription(description);+ r.setDescription(description);+ }+ repositories.putForAccount(owner, key, r);+ return r;+ }++ public PaginatedResult<CodeArtifactRepository> listRepositories(String region, String repositoryPrefix,+ Integer maxResults, String nextToken) {+ String owner = regionResolver.getAccountId();+ List<CodeArtifactRepository> matching = repositories.scanForAccount(owner, k -> k.startsWith(region + "::"))+ .stream()+ .filter(r -> repositoryPrefix == null || r.getName().startsWith(repositoryPrefix))+ .toList();+ return Pagination.paginate(matching, r -> r.getDomainName() + "::" + r.getName(),+ maxResults, nextToken, 100, 1000, "ValidationException");+ }++ public PaginatedResult<CodeArtifactRepository> listRepositoriesInDomain(String region, String domain,+ String domainOwner,+ String administratorAccount,+ String repositoryPrefix,+ Integer maxResults, String nextToken) {+ String owner = effectiveOwner(domainOwner);+ requireDomain(owner, domainKey(region, domain));+ List<CodeArtifactRepository> matching = repositories+ .scanForAccount(owner, k -> k.startsWith(region + "::" + domain + "::"))+ .stream()+ .filter(r -> repositoryPrefix == null || r.getName().startsWith(repositoryPrefix))+ .filter(r -> administratorAccount == null || administratorAccount.equals(r.getAdministratorAccount()))+ .toList();+ return Pagination.paginate(matching, CodeArtifactRepository::getName,+ maxResults, nextToken, 100, 1000, "ValidationException");+ }++ public String getRepositoryEndpoint(String region, String domain, String domainOwner, String repository,+ String format, String endpointType) {+ if (format == null || !PACKAGE_FORMATS.contains(format)) {+ throw validation("format must be one of " + PACKAGE_FORMATS + ".");+ }+ if (endpointType != null && !ENDPOINT_TYPES.contains(endpointType)) {+ throw validation("endpointType must be one of " + ENDPOINT_TYPES + ".");+ }+ String owner = effectiveOwner(domainOwner);+ requireRepository(owner, repositoryKey(region, domain, repository));+ return config.effectiveBaseUrl() + "/codeartifact/" + format + "/" + domain + "/" + repository + "/";+ }++ public synchronized ResourcePolicy putRepositoryPermissionsPolicy(String region, String domain,+ String domainOwner, String repository,+ String policyDocument, String policyRevision) {+ String owner = effectiveOwner(domainOwner);+ String key = repositoryKey(region, domain, repository);+ CodeArtifactRepository r = requireRepository(owner, key);+ checkRevision(r.getPolicyRevision(), policyRevision);+ validatePolicyDocument(policyDocument);+ r.setPolicyDocument(policyDocument);+ r.setPolicyRevision(newRevision());+ repositories.putForAccount(owner, key, r);+ return new ResourcePolicy(r.getArn(), r.getPolicyRevision(), r.getPolicyDocument());+ }++ public ResourcePolicy getRepositoryPermissionsPolicy(String region, String domain, String domainOwner,+ String repository) {+ String owner = effectiveOwner(domainOwner);+ CodeArtifactRepository r = requireRepository(owner, repositoryKey(region, domain, repository));+ if (r.getPolicyDocument() == null) {+ throw notFound("No resource policy is associated with repository '" + repository + "'.");+ }+ return new ResourcePolicy(r.getArn(), r.getPolicyRevision(), r.getPolicyDocument());+ }++ public synchronized ResourcePolicy deleteRepositoryPermissionsPolicy(String region, String domain,+ String domainOwner, String repository,+ String policyRevision) {+ String owner = effectiveOwner(domainOwner);+ String key = repositoryKey(region, domain, repository);+ CodeArtifactRepository r = requireRepository(owner, key);+ if (r.getPolicyDocument() == null) {+ throw notFound("No resource policy is associated with repository '" + repository + "'.");+ }+ checkRevision(r.getPolicyRevision(), policyRevision);+ ResourcePolicy removed = new ResourcePolicy(r.getArn(), r.getPolicyRevision(), r.getPolicyDocument());+ r.setPolicyDocument(null);+ r.setPolicyRevision(null);+ repositories.putForAccount(owner, key, r);+ return removed;+ }++ public synchronized CodeArtifactRepository associateExternalConnection(String region, String domain,+ String domainOwner, String repository,+ String externalConnection) {+ String format = EXTERNAL_CONNECTIONS.get(externalConnection);+ if (format == null) {+ throw validation("externalConnection must be one of " + EXTERNAL_CONNECTIONS.keySet() + ".");+ }+ String owner = effectiveOwner(domainOwner);+ String key = repositoryKey(region, domain, repository);+ CodeArtifactRepository r = requireRepository(owner, key);+ if (!r.getExternalConnections().isEmpty()) {+ throw conflict("Repository '" + repository + "' already has an external connection; "+ + "a repository can only have one.");+ }+ if (!r.getUpstreams().isEmpty()) {+ throw conflict("Repository '" + repository + "' has upstream repositories; "+ + "a repository cannot have both an external connection and upstream repositories.");+ }+ List<ExternalConnection> connections = new ArrayList<>(r.getExternalConnections());+ connections.add(new ExternalConnection(externalConnection, format, "Available"));+ r.setExternalConnections(connections);+ repositories.putForAccount(owner, key, r);+ return r;+ }++ public synchronized CodeArtifactRepository disassociateExternalConnection(String region, String domain,+ String domainOwner, String repository,+ String externalConnection) {+ String owner = effectiveOwner(domainOwner);+ String key = repositoryKey(region, domain, repository);+ CodeArtifactRepository r = requireRepository(owner, key);+ List<ExternalConnection> connections = new ArrayList<>(r.getExternalConnections());+ boolean removed = connections.removeIf(ec -> ec.getExternalConnectionName().equals(externalConnection));+ if (!removed) {+ throw notFound("Repository '" + repository + "' has no external connection named '"+ + externalConnection + "'.");+ }+ r.setExternalConnections(connections);+ repositories.putForAccount(owner, key, r);+ return r;+ }++ // -------------------------------------------------------------------- tags++ public synchronized void tagResource(String resourceArn, Map<String, String> newTags) {+ ResourceRef ref = parseResourceArn(resourceArn);+ if (ref.repository() == null) {+ String key = domainKey(ref.region(), ref.domain());+ CodeArtifactDomain d = requireDomain(ref.owner(), key);+ d.setTags(validateTags(newTags, d.getTags()));+ domains.putForAccount(ref.owner(), key, d);+ } else {+ String key = repositoryKey(ref.region(), ref.domain(), ref.repository());+ CodeArtifactRepository r = requireRepository(ref.owner(), key);+ r.setTags(validateTags(newTags, r.getTags()));+ repositories.putForAccount(ref.owner(), key, r);+ }+ }++ public synchronized void untagResource(String resourceArn, List<String> tagKeys) {+ ResourceRef ref = parseResourceArn(resourceArn);+ if (ref.repository() == null) {+ String key = domainKey(ref.region(), ref.domain());+ CodeArtifactDomain d = requireDomain(ref.owner(), key);+ Map<String, String> tags = new LinkedHashMap<>(d.getTags());+ tagKeys.forEach(tags::remove);+ d.setTags(tags);+ domains.putForAccount(ref.owner(), key, d);+ } else {+ String key = repositoryKey(ref.region(), ref.domain(), ref.repository());+ CodeArtifactRepository r = requireRepository(ref.owner(), key);+ Map<String, String> tags = new LinkedHashMap<>(r.getTags());+ tagKeys.forEach(tags::remove);+ r.setTags(tags);+ repositories.putForAccount(ref.owner(), key, r);+ }+ }++ public Map<String, String> listTagsForResource(String resourceArn) {+ ResourceRef ref = parseResourceArn(resourceArn);+ if (ref.repository() == null) {+ return requireDomain(ref.owner(), domainKey(ref.region(), ref.domain())).getTags();+ }+ return requireRepository(ref.owner(), repositoryKey(ref.region(), ref.domain(), ref.repository())).getTags();+ }++ @Override+ public void clear() {+ domains.clear();+ repositories.clear();+ }++ // ----------------------------------------------------------------- helpers++ private record ResourceRef(String type, String region, String owner, String domain, String repository) {}++ private ResourceRef parseResourceArn(String resourceArn) {+ AwsArnUtils.Arn arn;+ try {+ arn = AwsArnUtils.parse(resourceArn);+ } catch (IllegalArgumentException e) {+ throw validation("resourceArn is not a valid ARN.");+ }+ if (!"codeartifact".equals(arn.service())) {+ throw validation("resourceArn must be a CodeArtifact ARN.");+ }+ String[] parts = arn.resource().split("/");+ if (parts.length == 2 && "domain".equals(parts[0])) {+ return new ResourceRef("domain", arn.region(), arn.accountId(), parts[1], null);+ }+ if (parts.length == 3 && "repository".equals(parts[0])) {+ return new ResourceRef("repository", arn.region(), arn.accountId(), parts[1], parts[2]);+ }+ throw validation("resourceArn must reference a domain or a repository.");+ }++ private String effectiveOwner(String domainOwner) {+ if (domainOwner == null || domainOwner.isBlank()) {+ return regionResolver.getAccountId();+ }+ if (!ACCOUNT_ID.matcher(domainOwner).matches()) {+ throw validation("domainOwner must be a 12-digit account ID.");+ }+ return domainOwner;+ }++ private int repositoryCountForDomain(String owner, String region, String domain) {+ return repositories.scanForAccount(owner, k -> k.startsWith(region + "::" + domain + "::")).size();+ }++ private void validateUpstreams(String owner, String region, String domain, String repository,+ List<String> upstreams) {+ if (upstreams == null) {+ return;+ }+ if (upstreams.size() > 10) {+ throw new AwsException("ServiceQuotaExceededException",+ "A repository can have a maximum of 10 direct upstream repositories.", 402);+ }+ for (String upstream : upstreams) {+ if (upstream.equals(repository)) {+ throw validation("A repository cannot be its own upstream.");+ }+ if (repositories.getForAccount(owner, repositoryKey(region, domain, upstream)).isEmpty()) {+ throw notFound("Upstream repository '" + upstream + "' was not found in domain '" + domain + "'.");+ }+ }+ }++ private CodeArtifactDomain requireDomain(String owner, String key) {+ return domains.getForAccount(owner, key)+ .orElseThrow(() -> notFound("Domain not found."));+ }++ private CodeArtifactRepository requireRepository(String owner, String key) {+ return repositories.getForAccount(owner, key)+ .orElseThrow(() -> notFound("Repository not found."));+ }++ private void checkRevision(String currentRevision, String requestedRevision) {+ if (requestedRevision != null && !requestedRevision.equals(currentRevision)) {+ throw conflict("The policy revision does not match the current policy revision.");+ }+ }++ private static String newRevision() {+ return UUID.randomUUID().toString();+ }++ private static void validatePolicyDocument(String policyDocument) {+ if (policyDocument == null || policyDocument.isBlank() || policyDocument.length() > 7168) {+ throw validation("policyDocument must be 1-7168 characters.");+ }+ }++ private static void validateDescription(String description) {+ if (description != null && description.length() > 1000) {+ throw validation("description must be at most 1000 characters.");+ }+ }++ private static void validateDomainName(String domain) {+ if (domain == null || !DOMAIN_NAME.matcher(domain).matches()) {+ throw validation("domain must be 2-50 characters and match [a-z][a-z0-9-]*[a-z0-9].");+ }+ }++ private static void validateRepositoryName(String repository) {+ if (repository == null || !REPOSITORY_NAME.matcher(repository).matches()) {+ throw validation("repository must be 2-100 characters and match [A-Za-z0-9][A-Za-z0-9._-]*.");+ }+ }++ private static Map<String, String> validateTags(Map<String, String> newTags, Map<String, String> existing) {+ Map<String, String> merged = new LinkedHashMap<>(existing);+ if (newTags == null) {+ return merged;+ }+ newTags.forEach((k, v) -> {+ if (k == null || k.isBlank() || k.length() > 128 || k.startsWith("aws:")) {+ throw validation("Tag key '" + k + "' is invalid.");+ }+ if (v == null || v.length() > 256) {+ throw validation("Tag value for key '" + k + "' is invalid.");+ }+ merged.put(k, v);+ });+ if (merged.size() > 200) {+ throw new AwsException("ServiceQuotaExceededException",+ "The maximum number of tags (200) for this resource has been exceeded.", 402);+ }+ return merged;+ }++ private static String domainKey(String region, String domain) {+ return region + "::" + domain;+ }++ private static String repositoryKey(String region, String domain, String repository) {+ return region + "::" + domain + "::" + repository;+ }++ private static AwsException validation(String message) {+ return new AwsException("ValidationException", message, 400);+ }++ private static AwsException conflict(String message) {+ return new AwsException("ConflictException", message, 409);+ }++ private static AwsException notFound(String message) {+ return new AwsException("ResourceNotFoundException", message, 404);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactTagHandler.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactTagHandler.javanew file mode 100644index 0000000000..ac3162bf4e--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactTagHandler.java@@ -0,0 +1,72 @@+package io.github.hectorvent.floci.services.codeartifact;++import io.github.hectorvent.floci.core.common.TagHandler;+import io.github.hectorvent.floci.core.common.V1Tags;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.util.List;+import java.util.Map;++/**+ * CodeArtifact's {@code ListTagsForResource}, which AWS puts on the bare+ * {@code /v1/tags} path with {@code resourceArn} as a query parameter rather than a path+ * segment. {@code TagResource}/{@code UntagResource} don't collide with anything and stay on+ * {@code CodeArtifactController}'s own {@code /v1/tag} and {@code /v1/untag} routes; only the+ * list operation is registered here so {@code V1TagsController} can resolve it.+ *+ * <p>A separate bean rather than {@code CodeArtifactService} implementing {@link TagHandler}+ * itself, for the same reason as {@code MskTagHandler}: a class-level {@link V1Tags} would+ * strip the service's {@code @Default} qualifier and break plain {@code @Inject+ * CodeArtifactService} injection points.+ *+ * <p>CodeArtifact is the one {@link TagHandler} on this dispatcher with a list-shaped tag body+ * using lowercase {@code key}/{@code value} entry members rather than the AWS-typical+ * capitalized {@code Key}/{@code Value}.+ */+@ApplicationScoped+@V1Tags+public class CodeArtifactTagHandler implements TagHandler {++ private final CodeArtifactService codeArtifactService;++ @Inject+ public CodeArtifactTagHandler(CodeArtifactService codeArtifactService) {+ this.codeArtifactService = codeArtifactService;+ }++ @Override+ public String serviceKey() {+ return "codeartifact";+ }++ @Override+ public boolean tagsBodyIsList() {+ return true;+ }++ @Override+ public String tagEntryKeyName() {+ return "key";+ }++ @Override+ public String tagEntryValueName() {+ return "value";+ }++ @Override+ public Map<String, String> listTags(String region, String arn) {+ return codeArtifactService.listTagsForResource(arn);+ }++ @Override+ public void tagResource(String region, String arn, Map<String, String> tags) {+ codeArtifactService.tagResource(arn, tags);+ }++ @Override+ public void untagResource(String region, String arn, List<String> tagKeys) {+ codeArtifactService.untagResource(arn, tagKeys);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/CodeArtifactDomain.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/CodeArtifactDomain.javanew file mode 100644index 0000000000..016f093268--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/CodeArtifactDomain.java@@ -0,0 +1,94 @@+package io.github.hectorvent.floci.services.codeartifact.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.Collections;+import java.util.LinkedHashMap;+import java.util.Map;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class CodeArtifactDomain {+ private String name;+ private String owner;+ private String region;+ private String arn;+ private String encryptionKey;+ private long createdTime;+ private Map<String, String> tags = new LinkedHashMap<>();+ private String policyDocument;+ private String policyRevision;++ public String getName() {+ return name;+ }++ public void setName(String name) {+ this.name = name;+ }++ public String getOwner() {+ return owner;+ }++ public void setOwner(String owner) {+ this.owner = owner;+ }++ public String getRegion() {+ return region;+ }++ public void setRegion(String region) {+ this.region = region;+ }++ public String getArn() {+ return arn;+ }++ public void setArn(String arn) {+ this.arn = arn;+ }++ public String getEncryptionKey() {+ return encryptionKey;+ }++ public void setEncryptionKey(String encryptionKey) {+ this.encryptionKey = encryptionKey;+ }++ public long getCreatedTime() {+ return createdTime;+ }++ public void setCreatedTime(long createdTime) {+ this.createdTime = createdTime;+ }++ public Map<String, String> getTags() {+ return Collections.unmodifiableMap(tags);+ }++ public void setTags(Map<String, String> tags) {+ this.tags = tags;+ }++ public String getPolicyDocument() {+ return policyDocument;+ }++ public void setPolicyDocument(String policyDocument) {+ this.policyDocument = policyDocument;+ }++ public String getPolicyRevision() {+ return policyRevision;+ }++ public void setPolicyRevision(String policyRevision) {+ this.policyRevision = policyRevision;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/CodeArtifactRepository.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/CodeArtifactRepository.javanew file mode 100644index 0000000000..19cbd800e2--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/CodeArtifactRepository.java@@ -0,0 +1,132 @@+package io.github.hectorvent.floci.services.codeartifact.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.ArrayList;+import java.util.Collections;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class CodeArtifactRepository {+ private String name;+ private String domainName;+ private String domainOwner;+ private String administratorAccount;+ private String region;+ private String arn;+ private String description;+ private List<String> upstreams = new ArrayList<>();+ private List<ExternalConnection> externalConnections = new ArrayList<>();+ private long createdTime;+ private Map<String, String> tags = new LinkedHashMap<>();+ private String policyDocument;+ private String policyRevision;++ public String getName() {+ return name;+ }++ public void setName(String name) {+ this.name = name;+ }++ public String getDomainName() {+ return domainName;+ }++ public void setDomainName(String domainName) {+ this.domainName = domainName;+ }++ public String getDomainOwner() {+ return domainOwner;+ }++ public void setDomainOwner(String domainOwner) {+ this.domainOwner = domainOwner;+ }++ public String getAdministratorAccount() {+ return administratorAccount;+ }++ public void setAdministratorAccount(String administratorAccount) {+ this.administratorAccount = administratorAccount;+ }++ public String getRegion() {+ return region;+ }++ public void setRegion(String region) {+ this.region = region;+ }++ public String getArn() {+ return arn;+ }++ public void setArn(String arn) {+ this.arn = arn;+ }++ public String getDescription() {+ return description;+ }++ public void setDescription(String description) {+ this.description = description;+ }++ public List<String> getUpstreams() {+ return Collections.unmodifiableList(upstreams);+ }++ public void setUpstreams(List<String> upstreams) {+ this.upstreams = upstreams;+ }++ public List<ExternalConnection> getExternalConnections() {+ return Collections.unmodifiableList(externalConnections);+ }++ public void setExternalConnections(List<ExternalConnection> externalConnections) {+ this.externalConnections = externalConnections;+ }++ public long getCreatedTime() {+ return createdTime;+ }++ public void setCreatedTime(long createdTime) {+ this.createdTime = createdTime;+ }++ public Map<String, String> getTags() {+ return Collections.unmodifiableMap(tags);+ }++ public void setTags(Map<String, String> tags) {+ this.tags = tags;+ }++ public String getPolicyDocument() {+ return policyDocument;+ }++ public void setPolicyDocument(String policyDocument) {+ this.policyDocument = policyDocument;+ }++ public String getPolicyRevision() {+ return policyRevision;+ }++ public void setPolicyRevision(String policyRevision) {+ this.policyRevision = policyRevision;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/ExternalConnection.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/ExternalConnection.javanew file mode 100644index 0000000000..b3f21507ff--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/model/ExternalConnection.java@@ -0,0 +1,45 @@+package io.github.hectorvent.floci.services.codeartifact.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class ExternalConnection {+ private String externalConnectionName;+ private String packageFormat;+ private String status;++ public ExternalConnection() {+ }++ public ExternalConnection(String externalConnectionName, String packageFormat, String status) {+ this.externalConnectionName = externalConnectionName;+ this.packageFormat = packageFormat;+ this.status = status;+ }++ public String getExternalConnectionName() {+ return externalConnectionName;+ }++ public void setExternalConnectionName(String externalConnectionName) {+ this.externalConnectionName = externalConnectionName;+ }++ public String getPackageFormat() {+ return packageFormat;+ }++ public void setPackageFormat(String packageFormat) {+ this.packageFormat = packageFormat;+ }++ public String getStatus() {+ return status;+ }++ public void setStatus(String status) {+ this.status = status;+ }+}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 47a0e125e6..f53cf60801 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -793,5 +793,7 @@ floci:enabled: truecodegurureviewer:enabled: true+ codeartifact:+ enabled: truemarketplace:enabled: truediff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactIntegrationTest.javanew file mode 100644index 0000000000..ea3d82ffbc--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactIntegrationTest.java@@ -0,0 +1,132 @@+package io.github.hectorvent.floci.services.codeartifact;++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.emptyIterable;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasSize;+import static org.hamcrest.Matchers.notNullValue;++@QuarkusTest+class CodeArtifactIntegrationTest {+ private static final String AUTH = "AWS4-HMAC-SHA256 Credential=AKID/20260904/us-east-1/codeartifact/aws4_request";++ @BeforeAll+ static void configureRestAssured() { RestAssuredJsonUtils.configureAwsContentTypes(); }++ @Test+ void domainAndRepositoryLifecycle() {+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{\"tags\":[{\"key\":\"owner\",\"value\":\"platform\"}]}")+ .post("/v1/domain?domain=lifecycle-domain")+ .then().statusCode(200)+ .body("domain.name", equalTo("lifecycle-domain"))+ .body("domain.repositoryCount", equalTo(0))+ .body("domain.arn", notNullValue());++ given().header("Authorization", AUTH).get("/v1/domain?domain=lifecycle-domain")+ .then().statusCode(200).body("domain.status", equalTo("Active"));++ given().contentType("application/json").header("Authorization", AUTH)+ .body("{\"description\":\"a repo\"}")+ .post("/v1/repository?domain=lifecycle-domain&repository=lifecycle-repo")+ .then().statusCode(200)+ .body("repository.name", equalTo("lifecycle-repo"))+ .body("repository.domainName", equalTo("lifecycle-domain"))+ .body("repository.upstreams", emptyIterable());++ given().header("Authorization", AUTH)+ .get("/v1/repository/endpoint?domain=lifecycle-domain&repository=lifecycle-repo&format=npm")+ .then().statusCode(200)+ .body("repositoryEndpoint", equalTo("http://localhost:4566/codeartifact/npm/lifecycle-domain/lifecycle-repo/"));++ given().header("Authorization", AUTH)+ .delete("/v1/domain?domain=lifecycle-domain")+ .then().statusCode(409).body("__type", equalTo("ConflictException"));++ given().header("Authorization", AUTH)+ .delete("/v1/repository?domain=lifecycle-domain&repository=lifecycle-repo")+ .then().statusCode(200);++ given().header("Authorization", AUTH)+ .delete("/v1/domain?domain=lifecycle-domain")+ .then().statusCode(200);+ }++ @Test+ void tagResourceListTagsAndUntagResourceRoundTrip() {+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/domain?domain=tag-domain").then().statusCode(200);++ String arn = "arn:aws:codeartifact:us-east-1:000000000000:domain/tag-domain";++ given().contentType("application/json").header("Authorization", AUTH)+ .body("{\"tags\":[{\"key\":\"team\",\"value\":\"data\"}]}")+ .post("/v1/tag?resourceArn=" + arn)+ .then().statusCode(200);++ given().contentType("application/json").header("Authorization", AUTH)+ .post("/v1/tags?resourceArn=" + arn)+ .then().statusCode(200)+ .body("tags", hasSize(1))+ .body("tags[0].key", equalTo("team"))+ .body("tags[0].value", equalTo("data"));++ given().contentType("application/json").header("Authorization", AUTH)+ .body("{\"tagKeys\":[\"team\"]}")+ .post("/v1/untag?resourceArn=" + arn)+ .then().statusCode(200);++ given().contentType("application/json").header("Authorization", AUTH)+ .post("/v1/tags?resourceArn=" + arn)+ .then().statusCode(200).body("tags", hasSize(0));+ }++ @Test+ void listDomainsReturnsSummaryShapeNotFullDescription() {+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/domain?domain=summary-domain").then().statusCode(200);++ given().contentType("application/json").header("Authorization", AUTH).body("{}")+ .post("/v1/domains")+ .then().statusCode(200)+ .body("domains.find { it.name == 'summary-domain' }.owner", notNullValue())+ .body("domains.find { it.name == 'summary-domain' }.repositoryCount", equalTo(null));+ }++ @Test+ void deleteRepositoryPermissionsPolicyUsesPluralPath() {+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/domain?domain=policy-domain").then().statusCode(200);+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/repository?domain=policy-domain&repository=policy-repo")+ .then().statusCode(200);++ given().contentType("application/json").header("Authorization", AUTH)+ .body("{\"policyDocument\":\"{}\"}")+ .put("/v1/repository/permissions/policy?domain=policy-domain&repository=policy-repo")+ .then().statusCode(200).body("policy.document", equalTo("{}"));++ given().header("Authorization", AUTH)+ .delete("/v1/repository/permissions/policies?domain=policy-domain&repository=policy-repo")+ .then().statusCode(200);+ }++ @Test+ void createRepositoryUnderMissingDomainReturnsNotFound() {+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/repository?domain=no-such-domain&repository=valid-repo")+ .then().statusCode(404).body("__type", equalTo("ResourceNotFoundException"));+ }++ @Test+ void invalidDomainNameReturnsValidationError() {+ given().contentType("application/json").header("Authorization", AUTH)+ .body("{}").post("/v1/domain?domain=NOT-VALID")+ .then().statusCode(400).body("__type", equalTo("ValidationException"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.javanew file mode 100644index 0000000000..cccce4072d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.java@@ -0,0 +1,355 @@+package io.github.hectorvent.floci.services.codeartifact;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.PaginatedResult;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.DomainView;+import io.github.hectorvent.floci.services.codeartifact.CodeArtifactService.ResourcePolicy;+import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactDomain;+import io.github.hectorvent.floci.services.codeartifact.model.CodeArtifactRepository;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.ArrayList;+import java.util.List;+import java.util.Map;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicInteger;++import static org.junit.jupiter.api.Assertions.assertEquals;+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.when;++class CodeArtifactServiceTest {+ private static final String REGION = "us-east-1";+ private static final String OTHER_REGION = "us-west-2";+ private static final String ACCOUNT_ID = "123456789012";++ private CodeArtifactService service;++ @BeforeEach+ @SuppressWarnings({"unchecked", "rawtypes"})+ void setUp() {+ StorageFactory storageFactory = mock(StorageFactory.class);+ AccountAwareStorageBackend<CodeArtifactDomain> domainStore = AccountAwareStorageBackend.inMemory(ACCOUNT_ID);+ AccountAwareStorageBackend<CodeArtifactRepository> repoStore = AccountAwareStorageBackend.inMemory(ACCOUNT_ID);+ when(storageFactory.create(eq("codeartifact"), eq("codeartifact-domains.json"), any(TypeReference.class)))+ .thenReturn((AccountAwareStorageBackend) domainStore);+ when(storageFactory.create(eq("codeartifact"), eq("codeartifact-repositories.json"), any(TypeReference.class)))+ .thenReturn((AccountAwareStorageBackend) repoStore);++ RegionResolver regionResolver = mock(RegionResolver.class);+ when(regionResolver.getAccountId()).thenReturn(ACCOUNT_ID);+ when(regionResolver.buildArn(anyString(), anyString(), anyString())).thenAnswer(invocation ->+ "arn:aws:" + invocation.getArgument(0, String.class) + ":" + invocation.getArgument(1, String.class)+ + ":" + ACCOUNT_ID + ":" + invocation.getArgument(2, String.class));++ EmulatorConfig config = mock(EmulatorConfig.class);+ when(config.effectiveBaseUrl()).thenReturn("http://localhost:4566");++ service = new CodeArtifactService(storageFactory, regionResolver, config);+ }++ // -------------------------------------------------------------- domains++ @Test+ void createDomainAssignsArnAndDefaultEncryptionKey() {+ DomainView view = service.createDomain(REGION, "my-domain", null, Map.of());+ assertEquals("arn:aws:codeartifact:" + REGION + ":" + ACCOUNT_ID + ":domain/my-domain", view.domain().getArn());+ assertTrue(view.domain().getEncryptionKey().contains("alias/aws/codeartifact"));+ assertEquals(0, view.repositoryCount());+ }++ @Test+ void createDomainRejectsDuplicateName() {+ service.createDomain(REGION, "dup", null, Map.of());+ AwsException e = assertThrows(AwsException.class, () -> service.createDomain(REGION, "dup", null, Map.of()));+ assertEquals("ConflictException", e.getErrorCode());+ }++ @Test+ void createDomainRejectsInvalidName() {+ AwsException e = assertThrows(AwsException.class,+ () -> service.createDomain(REGION, "Not-Valid-Upper", null, Map.of()));+ assertEquals("ValidationException", e.getErrorCode());+ }++ @Test+ void domainsAreScopedPerRegion() {+ service.createDomain(REGION, "shared-name", null, Map.of());+ DomainView otherRegion = service.createDomain(OTHER_REGION, "shared-name", null, Map.of());+ assertTrue(otherRegion.domain().getArn().contains(OTHER_REGION));+ assertEquals(1, service.listDomains(REGION, null, null).items().size());+ assertEquals(1, service.listDomains(OTHER_REGION, null, null).items().size());+ }++ @Test+ void deleteDomainFailsWhileRepositoriesExist() {+ service.createDomain(REGION, "with-repo", null, Map.of());+ service.createRepository(REGION, "with-repo", null, "repo-a", null, null, Map.of());++ AwsException e = assertThrows(AwsException.class, () -> service.deleteDomain(REGION, "with-repo", null));+ assertEquals("ConflictException", e.getErrorCode());++ service.deleteRepository(REGION, "with-repo", null, "repo-a");+ DomainView deleted = service.deleteDomain(REGION, "with-repo", null);+ assertEquals("with-repo", deleted.domain().getName());+ }++ @Test+ void describeDomainReflectsLiveRepositoryCount() {+ service.createDomain(REGION, "counted", null, Map.of());+ assertEquals(0, service.describeDomain(REGION, "counted", null).repositoryCount());+ service.createRepository(REGION, "counted", null, "repo-a", null, null, Map.of());+ service.createRepository(REGION, "counted", null, "repo-b", null, null, Map.of());+ assertEquals(2, service.describeDomain(REGION, "counted", null).repositoryCount());+ }++ @Test+ void concurrentCreateDomainWithSameNameOnlyOneWins() throws InterruptedException {+ int attempts = 8;+ ExecutorService pool = Executors.newFixedThreadPool(attempts);+ CountDownLatch ready = new CountDownLatch(attempts);+ CountDownLatch go = new CountDownLatch(1);+ AtomicInteger successes = new AtomicInteger();+ AtomicInteger conflicts = new AtomicInteger();+ try {+ for (int i = 0; i < attempts; i++) {+ pool.submit(() -> {+ ready.countDown();+ try {+ go.await();+ service.createDomain(REGION, "race-domain", null, Map.of());+ successes.incrementAndGet();+ } catch (AwsException e) {+ if ("ConflictException".equals(e.getErrorCode())) {+ conflicts.incrementAndGet();+ }+ } catch (InterruptedException ignored) {+ Thread.currentThread().interrupt();+ }+ });+ }+ ready.await(5, TimeUnit.SECONDS);+ go.countDown();+ } finally {+ pool.shutdown();+ assertTrue(pool.awaitTermination(10, TimeUnit.SECONDS));+ }+ assertEquals(1, successes.get());+ assertEquals(attempts - 1, conflicts.get());+ }++ // ---------------------------------------------------------- repositories++ @Test+ void createRepositoryRequiresExistingDomain() {+ AwsException e = assertThrows(AwsException.class,+ () -> service.createRepository(REGION, "missing-domain", null, "repo", null, null, Map.of()));+ assertEquals("ResourceNotFoundException", e.getErrorCode());+ }++ @Test+ void createRepositoryValidatesUpstreamsExistInSameDomain() {+ service.createDomain(REGION, "dom", null, Map.of());+ AwsException e = assertThrows(AwsException.class,+ () -> service.createRepository(REGION, "dom", null, "repo", null, List.of("ghost"), Map.of()));+ assertEquals("ResourceNotFoundException", e.getErrorCode());+ }++ @Test+ void createRepositoryRejectsSelfAsUpstream() {+ service.createDomain(REGION, "dom", null, Map.of());+ AwsException e = assertThrows(AwsException.class,+ () -> service.createRepository(REGION, "dom", null, "repo", null, List.of("repo"), Map.of()));+ assertEquals("ValidationException", e.getErrorCode());+ }++ @Test+ void createRepositoryAcceptsExistingUpstream() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "store", null, null, Map.of());+ CodeArtifactRepository r = service.createRepository(REGION, "dom", null, "consumer", null,+ List.of("store"), Map.of());+ assertEquals(List.of("store"), r.getUpstreams());+ }++ @Test+ void updateRepositoryChangesDescriptionAndUpstreams() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "store", null, null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", "old", null, Map.of());++ CodeArtifactRepository updated = service.updateRepository(REGION, "dom", null, "repo", "new",+ List.of("store"));+ assertEquals("new", updated.getDescription());+ assertEquals(List.of("store"), updated.getUpstreams());+ }++ @Test+ void createRepositoryRejectsMoreThanTenUpstreams() {+ service.createDomain(REGION, "dom", null, Map.of());+ List<String> upstreams = new ArrayList<>();+ for (int i = 0; i < 11; i++) {+ String name = "store-" + i;+ service.createRepository(REGION, "dom", null, name, null, null, Map.of());+ upstreams.add(name);+ }+ AwsException e = assertThrows(AwsException.class,+ () -> service.createRepository(REGION, "dom", null, "consumer", null, upstreams, Map.of()));+ assertEquals("ServiceQuotaExceededException", e.getErrorCode());+ }++ @Test+ void listRepositoriesInDomainFiltersByPrefixAndDomain() {+ service.createDomain(REGION, "dom-a", null, Map.of());+ service.createDomain(REGION, "dom-b", null, Map.of());+ service.createRepository(REGION, "dom-a", null, "npm-repo", null, null, Map.of());+ service.createRepository(REGION, "dom-a", null, "pypi-repo", null, null, Map.of());+ service.createRepository(REGION, "dom-b", null, "npm-repo", null, null, Map.of());++ PaginatedResult<CodeArtifactRepository> page = service.listRepositoriesInDomain(REGION, "dom-a", null, null,+ "npm", null, null);+ assertEquals(1, page.items().size());+ assertEquals("npm-repo", page.items().get(0).getName());+ }++ @Test+ void getRepositoryEndpointValidatesFormatAndReturnsStableUrl() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());++ String endpoint = service.getRepositoryEndpoint(REGION, "dom", null, "repo", "npm", null);+ assertEquals("http://localhost:4566/codeartifact/npm/dom/repo/", endpoint);++ AwsException e = assertThrows(AwsException.class,+ () -> service.getRepositoryEndpoint(REGION, "dom", null, "repo", "not-a-format", null));+ assertEquals("ValidationException", e.getErrorCode());+ }++ // ------------------------------------------------------ permissions policy++ @Test+ void putRepositoryPermissionsPolicyEnforcesOptimisticLocking() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());++ ResourcePolicy first = service.putRepositoryPermissionsPolicy(REGION, "dom", null, "repo", "{}", null);++ AwsException stale = assertThrows(AwsException.class, () -> service.putRepositoryPermissionsPolicy(+ REGION, "dom", null, "repo", "{}", "not-the-current-revision"));+ assertEquals("ConflictException", stale.getErrorCode());++ ResourcePolicy second = service.putRepositoryPermissionsPolicy(REGION, "dom", null, "repo", "{\"v\":2}",+ first.revision());+ assertEquals("{\"v\":2}", second.document());++ ResourcePolicy fetched = service.getRepositoryPermissionsPolicy(REGION, "dom", null, "repo");+ assertEquals(second.revision(), fetched.revision());++ service.deleteRepositoryPermissionsPolicy(REGION, "dom", null, "repo", second.revision());+ AwsException gone = assertThrows(AwsException.class,+ () -> service.getRepositoryPermissionsPolicy(REGION, "dom", null, "repo"));+ assertEquals("ResourceNotFoundException", gone.getErrorCode());+ }++ // ------------------------------------------------------- external connections++ @Test+ void associateExternalConnectionRejectsUnknownName() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ AwsException e = assertThrows(AwsException.class,+ () -> service.associateExternalConnection(REGION, "dom", null, "repo", "public:not-real"));+ assertEquals("ValidationException", e.getErrorCode());+ }++ @Test+ void repositoryCanOnlyHaveOneExternalConnection() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ CodeArtifactRepository r = service.associateExternalConnection(REGION, "dom", null, "repo", "public:npmjs");+ assertEquals("npm", r.getExternalConnections().get(0).getPackageFormat());+ assertEquals("Available", r.getExternalConnections().get(0).getStatus());++ AwsException e = assertThrows(AwsException.class,+ () -> service.associateExternalConnection(REGION, "dom", null, "repo", "public:pypi"));+ assertEquals("ConflictException", e.getErrorCode());++ CodeArtifactRepository disassociated = service.disassociateExternalConnection(REGION, "dom", null, "repo",+ "public:npmjs");+ assertTrue(disassociated.getExternalConnections().isEmpty());+ }++ @Test+ void externalConnectionAndUpstreamsAreMutuallyExclusive() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "store", null, null, Map.of());+ service.createRepository(REGION, "dom", null, "with-upstream", null, List.of("store"), Map.of());++ AwsException viaExternalConnection = assertThrows(AwsException.class, () -> service+ .associateExternalConnection(REGION, "dom", null, "with-upstream", "public:npmjs"));+ assertEquals("ConflictException", viaExternalConnection.getErrorCode());++ service.createRepository(REGION, "dom", null, "with-connection", null, null, Map.of());+ service.associateExternalConnection(REGION, "dom", null, "with-connection", "public:npmjs");+ AwsException viaUpstream = assertThrows(AwsException.class, () -> service+ .updateRepository(REGION, "dom", null, "with-connection", null, List.of("store")));+ assertEquals("ConflictException", viaUpstream.getErrorCode());+ }++ // ------------------------------------------------------------------- tags++ @Test+ void tagAndUntagResourceRoundTripForDomainAndRepository() {+ DomainView domain = service.createDomain(REGION, "dom", null, Map.of());+ CodeArtifactRepository repo = service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());++ service.tagResource(domain.domain().getArn(), Map.of("owner", "platform"));+ assertEquals(Map.of("owner", "platform"), service.listTagsForResource(domain.domain().getArn()));+ service.untagResource(domain.domain().getArn(), List.of("owner"));+ assertTrue(service.listTagsForResource(domain.domain().getArn()).isEmpty());++ service.tagResource(repo.getArn(), Map.of("team", "data"));+ assertEquals(Map.of("team", "data"), service.listTagsForResource(repo.getArn()));+ }++ @Test+ void tagResourceRejectsAwsReservedPrefix() {+ DomainView domain = service.createDomain(REGION, "dom", null, Map.of());+ AwsException e = assertThrows(AwsException.class,+ () -> service.tagResource(domain.domain().getArn(), Map.of("aws:reserved", "x")));+ assertEquals("ValidationException", e.getErrorCode());+ }++ @Test+ void tagResourceRejectsUnknownResourceArn() {+ AwsException e = assertThrows(AwsException.class,+ () -> service.tagResource("arn:aws:codeartifact:" + REGION + ":" + ACCOUNT_ID + ":domain/ghost",+ Map.of("k", "v")));+ assertEquals("ResourceNotFoundException", e.getErrorCode());+ }++ @Test+ void clearRemovesAllPersistedState() {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ service.clear();+ assertTrue(service.listDomains(REGION, null, null).items().isEmpty());+ AwsException e = assertThrows(AwsException.class,+ () -> service.describeRepository(REGION, "dom", null, "repo"));+ assertEquals("ResourceNotFoundException", e.getErrorCode());+ }+}diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex 313c849c2f..8b47862c24 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -488,5 +488,7 @@ floci:enabled: truecodegurureviewer:enabled: true+ codeartifact:+ enabled: truemarketplace:enabled: truediff --git a/tools/docs/services.yaml b/tools/docs/services.yamlindex aaa5622b7d..c8f417b70a 100644--- a/tools/docs/services.yaml+++ b/tools/docs/services.yaml@@ -72,6 +72,17 @@ services:doc: docs/services/cloudtrail.mdsources:- { path: src/main/java/io/github/hectorvent/floci/services/cloudtrail/CloudTrailJsonHandler.java, mode: switch }+ - service: codeartifact+ doc: docs/services/codeartifact.md+ sources:+ - { path: src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactController.java, mode: rest }+ - { path: src/main/java/io/github/hectorvent/floci/core/common/V1TagsController.java, mode: rest }+ rename_actions:+ ListTagsForResourceByQuery: ListTagsForResource+ exclude_actions:+ - ListTags+ - TagResourcePost+ - TagResourcePut- service: codegurureviewerdoc: docs/services/codegurureviewer.mdsources: