Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

feat(ecr): repository creation templates (#5955)

Davidd10db3ce9b25
diff --git a/compatibility-tests/sdk-test-awscli/test/ecr.bats b/compatibility-tests/sdk-test-awscli/test/ecr.bats
index 2ba5b09e76..136b08b13c 100644
--- a/compatibility-tests/sdk-test-awscli/test/ecr.bats
+++ b/compatibility-tests/sdk-test-awscli/test/ecr.bats
@@ -170,3 +170,25 @@ teardown() {
assert_failure
[[ "$output" == *"RegistryPolicyNotFoundException"* ]]
}
+
+@test "ECR: repository creation templates round-trip" {
+ prefix="floci-cli-$(unique_name)"
+ run aws_cmd ecr create-repository-creation-template --prefix "$prefix" \
+ --applied-for PULL_THROUGH_CACHE --description "cli template"
+ assert_success
+ [ "$(json_get "$output" '.repositoryCreationTemplate.encryptionConfiguration.encryptionType')" = "AES256" ]
+
+ run aws_cmd ecr update-repository-creation-template --prefix "$prefix" --image-tag-mutability IMMUTABLE
+ assert_success
+ [ "$(json_get "$output" '.repositoryCreationTemplate.imageTagMutability')" = "IMMUTABLE" ]
+
+ run aws_cmd ecr describe-repository-creation-templates --prefixes "$prefix"
+ assert_success
+ [ "$(json_get "$output" '.repositoryCreationTemplates[0].description')" = "cli template" ]
+
+ run aws_cmd ecr delete-repository-creation-template --prefix "$prefix"
+ assert_success
+ run aws_cmd ecr delete-repository-creation-template --prefix "$prefix"
+ assert_failure
+ [[ "$output" == *"TemplateNotFoundException"* ]]
+}
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EcrTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EcrTest.java
index adf275ed3e..5841c3c7fb 100644
--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EcrTest.java
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/EcrTest.java
@@ -374,4 +374,50 @@ class EcrTest {
ecr.putRegistryScanningConfiguration(b -> b.scanType(ScanType.BASIC).rules(List.of()));
}
}
+
+ @Test
+ @Order(15)
+ @DisplayName("Repository creation templates create, update, describe and delete")
+ void repositoryCreationTemplateLifecycle() {
+ String prefix = "floci-sdk-" + System.currentTimeMillis();
+ try {
+ CreateRepositoryCreationTemplateResponse created = ecr.createRepositoryCreationTemplate(b -> b
+ .prefix(prefix)
+ .description("sdk template")
+ .appliedFor(RCTAppliedFor.PULL_THROUGH_CACHE, RCTAppliedFor.REPLICATION)
+ .resourceTags(Tag.builder().key("team").value("platform").build())
+ .imageTagMutability(ImageTagMutability.IMMUTABLE));
+ assertThat(created.registryId()).isEqualTo("000000000000");
+ assertThat(created.repositoryCreationTemplate().prefix()).isEqualTo(prefix);
+ assertThat(created.repositoryCreationTemplate().encryptionConfiguration().encryptionType())
+ .isEqualTo(EncryptionType.AES256);
+ assertThat(created.repositoryCreationTemplate().createdAt()).isNotNull();
+ assertThatThrownBy(() -> ecr.createRepositoryCreationTemplate(b -> b
+ .prefix(prefix).appliedFor(RCTAppliedFor.REPLICATION)))
+ .isInstanceOf(TemplateAlreadyExistsException.class);
+
+ UpdateRepositoryCreationTemplateResponse updated = ecr.updateRepositoryCreationTemplate(b -> b
+ .prefix(prefix)
+ .appliedFor(RCTAppliedFor.CREATE_ON_PUSH));
+ assertThat(updated.repositoryCreationTemplate().appliedFor()).containsExactly(RCTAppliedFor.CREATE_ON_PUSH);
+ assertThat(updated.repositoryCreationTemplate().description()).isEqualTo("sdk template");
+
+ DescribeRepositoryCreationTemplatesResponse described =
+ ecr.describeRepositoryCreationTemplates(b -> b.prefixes(prefix));
+ assertThat(described.repositoryCreationTemplates()).hasSize(1);
+ assertThat(described.repositoryCreationTemplates().get(0).resourceTags())
+ .containsExactly(Tag.builder().key("team").value("platform").build());
+
+ assertThat(ecr.deleteRepositoryCreationTemplate(b -> b.prefix(prefix))
+ .repositoryCreationTemplate().prefix()).isEqualTo(prefix);
+ assertThatThrownBy(() -> ecr.deleteRepositoryCreationTemplate(b -> b.prefix(prefix)))
+ .isInstanceOf(TemplateNotFoundException.class);
+ } finally {
+ try {
+ ecr.deleteRepositoryCreationTemplate(b -> b.prefix(prefix));
+ } catch (TemplateNotFoundException expected) {
+ // Already deleted by the lifecycle assertion.
+ }
+ }
+ }
}
diff --git a/docs/services/ecr.md b/docs/services/ecr.md
index aa0e94bbee..39e8cc889c 100644
--- a/docs/services/ecr.md
+++ b/docs/services/ecr.md
@@ -14,6 +14,10 @@
| `UpdatePullThroughCacheRule` | Update a rule's credential or custom role |
| `ValidatePullThroughCacheRule` | Validate that a configured rule exists and report it as usable |
| `DeletePullThroughCacheRule` | Delete a pull-through cache rule by repository prefix |
+| `CreateRepositoryCreationTemplate` | Store a repository creation template under its prefix (recorded, not applied) |
+| `DescribeRepositoryCreationTemplates` | List templates, or those for given prefixes, with pagination |
+| `UpdateRepositoryCreationTemplate` | Replace the fields a request sets on a template |
+| `DeleteRepositoryCreationTemplate` | Delete a template by prefix |
| `DescribeRepositories` | List repositories or fetch by name |
| `DeleteRepository` | Delete a repository (with `force=true` semantics for non-empty repos) |
| `GetAuthorizationToken` | Returns a docker-login token + proxy endpoint |
@@ -70,6 +74,7 @@ the optional `filter` fields.
- `GetRegistryPolicy` and `DeleteRegistryPolicy` answer `RegistryPolicyNotFoundException` when no policy is set. `PutRegistryPolicy` refuses text that is not a JSON object.
- An empty `rules` list in `PutReplicationConfiguration` clears the configuration. `DescribeRegistry` returns `{"rules": []}` until rules are set.
- The scanning configuration is `BASIC` with no rules until one is put. `CONTINUOUS_SCAN` is refused with `BASIC`, since AWS offers it only with enhanced scanning. `BatchGetRepositoryScanningConfiguration` still reports each repository's own `scanOnPush`. Missing repository names appear in `failures` with `REPOSITORY_NOT_FOUND`, alongside configurations for the names that exist.
+- **Repository creation templates.** Templates are kept per account and Region, keyed by `prefix` (`ROOT` included). A new template defaults to `AES256` encryption and `MUTABLE` tags. `UpdateRepositoryCreationTemplate` replaces each field the request sets, an empty string or list clears it, and fields left out are kept. The exclusion filters are the exception: the model requires at least one, so `[]` is refused. Instead, an update that leaves the template in a mode without exclusions (`MUTABLE` or `IMMUTABLE`) drops the filters, which is what Terraform relies on, since it leaves the member out when the filters are removed. `DescribeRepositoryCreationTemplates` leaves out a requested prefix with no template rather than failing. Requests are checked against the vendored ECR model constraints, as the registry settings are, with `InvalidParameterException`. On top of the model, `appliedFor` must name at least one value, and policy text must be a JSON object. Nothing in Floci creates repositories through replication, pull through cache or create-on-push, so templates are never applied.
- **Manifest format negotiation.** `BatchGetImage` forwards the caller's `acceptedMediaTypes` as the upstream `Accept` header. Modern OCI manifests (`application/vnd.oci.image.manifest.v1+json`) and Docker v2 schema 2 are both supported.
- **Cross-account / cross-region isolation.** Internally the registry namespaces repositories as `<account>/<region>/<repoName>`, so the same repository name in different accounts or regions cannot collide.
- **Reconcile on first start.** When the registry container starts, Floci queries `GET /v2/_catalog` and recreates `Repository` metadata entries for any namespaces present in the registry but missing from local storage. This means image bytes are never orphaned across restarts.
@@ -270,6 +275,7 @@ The following ECR features are **not** implemented. Stored values for policies a
- Image scanning (`StartImageScan`, `DescribeImageScanFindings`)
- Image signing and notary attachments
- Lifecycle policy enforcement (the policy text is stored but not applied)
+- Applying repository creation templates (they are stored, but Floci never creates repositories through replication, pull through cache or create-on-push)
- Repository policy enforcement (no IAM evaluation against repository-level policies)
- TLS via emulated ACM
diff --git a/docs/services/index.md b/docs/services/index.md
index 36872e9293..a5e918bb30 100644
--- a/docs/services/index.md
+++ b/docs/services/index.md
@@ -87,7 +87,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac
| [EC2](ec2.md) | `POST /` with `Action=` param | EC2 Query | 202 |
| [Lightsail](lightsail.md) | `POST /` + `X-Amz-Target: Lightsail_20161128.*` | JSON 1.1 | 79 local responses; 161 recognized actions |
| [ACM](acm.md) | `POST /` + `X-Amz-Target: CertificateManager.*` | JSON 1.1 | 16 |
-| [ECR](ecr.md) | `POST /` + `X-Amz-Target: AmazonEC2ContainerRegistry_V20150921.*` (control plane) and `/v2/...` (data plane proxied to `registry:2`) | JSON 1.1 + OCI Distribution | 30 |
+| [ECR](ecr.md) | `POST /` + `X-Amz-Target: AmazonEC2ContainerRegistry_V20150921.*` (control plane) and `/v2/...` (data plane proxied to `registry:2`) | JSON 1.1 + OCI Distribution | 34 |
| [AWS Resource Groups](resource-groups.md) | `/groups`, `/get-group`, `/delete-group`, `/group-resources`, `/list-group-resources` | REST JSON | 5 |
| [Resource Groups Tagging API](resource-groups-tagging.md) | `POST /` + `X-Amz-Target: ResourceGroupsTaggingAPI_20170126.*` | JSON 1.1 | 5 |
| [Resource Explorer](resource-explorer.md) | `POST /{OperationName}`, rewritten to `/_re2/*` for the four paths S3 Vectors also claims | REST JSON | 32 |
diff --git a/src/main/java/io/github/hectorvent/floci/services/ecr/EcrJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/ecr/EcrJsonHandler.java
index ace183a37d..81a86fce75 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ecr/EcrJsonHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ecr/EcrJsonHandler.java
@@ -16,6 +16,7 @@ import io.github.hectorvent.floci.services.ecr.model.ImageIdentifier;
import io.github.hectorvent.floci.services.ecr.model.PullThroughCacheRule;
import io.github.hectorvent.floci.services.ecr.model.RegistrySettings;
import io.github.hectorvent.floci.services.ecr.model.Repository;
+import io.github.hectorvent.floci.services.ecr.model.RepositoryCreationTemplate;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.core.Response;
@@ -49,7 +50,9 @@ public class EcrJsonHandler {
"PutRegistryPolicy", "GetRegistryPolicy", "DeleteRegistryPolicy",
"PutReplicationConfiguration", "DescribeRegistry",
"PutRegistryScanningConfiguration", "GetRegistryScanningConfiguration",
- "BatchGetRepositoryScanningConfiguration");
+ "BatchGetRepositoryScanningConfiguration",
+ "CreateRepositoryCreationTemplate", "UpdateRepositoryCreationTemplate",
+ "DescribeRepositoryCreationTemplates", "DeleteRepositoryCreationTemplate");
public Response handle(String action, JsonNode request, String region) {
if (MODEL_CHECKED.contains(action)) {
@@ -62,6 +65,10 @@ public class EcrJsonHandler {
case "UpdatePullThroughCacheRule" -> handleUpdatePullThroughCacheRule(request, region);
case "ValidatePullThroughCacheRule" -> handleValidatePullThroughCacheRule(request, region);
case "DeletePullThroughCacheRule" -> handleDeletePullThroughCacheRule(request, region);
+ case "CreateRepositoryCreationTemplate" -> handleCreateRepositoryCreationTemplate(request, region);
+ case "DescribeRepositoryCreationTemplates" -> handleDescribeRepositoryCreationTemplates(request, region);
+ case "UpdateRepositoryCreationTemplate" -> handleUpdateRepositoryCreationTemplate(request, region);
+ case "DeleteRepositoryCreationTemplate" -> handleDeleteRepositoryCreationTemplate(request, region);
case "DescribeRepositories" -> handleDescribeRepositories(request, region);
case "PutImageScanningConfiguration" -> handlePutImageScanningConfiguration(request, region);
case "BatchGetRepositoryScanningConfiguration" ->
@@ -850,6 +857,121 @@ public class EcrJsonHandler {
return n;
}
+ // ──────────────────────────── Repository creation templates ────────────────────────────
+
+ private Response handleCreateRepositoryCreationTemplate(JsonNode request, String region) {
+ return templateResponse(service.createRepositoryCreationTemplate(parseTemplate(request), region));
+ }
+
+ private Response handleUpdateRepositoryCreationTemplate(JsonNode request, String region) {
+ return templateResponse(service.updateRepositoryCreationTemplate(parseTemplate(request), region));
+ }
+
+ private Response handleDeleteRepositoryCreationTemplate(JsonNode request, String region) {
+ return templateResponse(service.deleteRepositoryCreationTemplate(
+ request.path("prefix").asText(null), region));
+ }
+
+ private Response handleDescribeRepositoryCreationTemplates(JsonNode request, String region) {
+ JsonNode prefixesNode = request.path("prefixes");
+ List<String> prefixes = prefixesNode.isMissingNode() || prefixesNode.isNull()
+ ? null
+ : parseStringList(prefixesNode);
+ PaginatedResult<RepositoryCreationTemplate> result = service.describeRepositoryCreationTemplates(
+ prefixes, parseMaxResults(request.path("maxResults")), request.path("nextToken").asText(null), region);
+ ObjectNode response = objectMapper.createObjectNode();
+ response.put("registryId", service.templateRegistryId());
+ ArrayNode templates = response.putArray("repositoryCreationTemplates");
+ result.items().forEach(t -> templates.add(buildTemplate(t)));
+ if (result.nextToken() != null) {
+ response.put("nextToken", result.nextToken());
+ }
+ return Response.ok(response).build();
+ }
+
+ private Response templateResponse(RepositoryCreationTemplate template) {
+ ObjectNode response = objectMapper.createObjectNode();
+ response.put("registryId", service.templateRegistryId());
+ response.set("repositoryCreationTemplate", buildTemplate(template));
+ return Response.ok(response).build();
+ }
+
+ /** The template fields a request sets; each one it leaves out stays null. */
+ private static RepositoryCreationTemplate parseTemplate(JsonNode request) {
+ RepositoryCreationTemplate t = new RepositoryCreationTemplate();
+ t.setPrefix(request.path("prefix").asText(null));
+ t.setDescription(request.path("description").asText(null));
+ JsonNode encryption = request.path("encryptionConfiguration");
+ if (encryption.isObject()) {
+ t.setEncryptionConfiguration(new RepositoryCreationTemplate.EncryptionConfiguration(
+ encryption.path("encryptionType").asText(null), encryption.path("kmsKey").asText(null)));
+ }
+ if (request.path("resourceTags").isArray()) {
+ List<RepositoryCreationTemplate.ResourceTag> tags = new ArrayList<>();
+ request.path("resourceTags").forEach(tag -> tags.add(new RepositoryCreationTemplate.ResourceTag(
+ tag.path("Key").asText(null), tag.path("Value").asText(null))));
+ t.setResourceTags(tags);
+ }
+ t.setImageTagMutability(request.path("imageTagMutability").asText(null));
+ if (request.path("imageTagMutabilityExclusionFilters").isArray()) {
+ List<RepositoryCreationTemplate.ExclusionFilter> filters = new ArrayList<>();
+ request.path("imageTagMutabilityExclusionFilters").forEach(f -> filters.add(
+ new RepositoryCreationTemplate.ExclusionFilter(
+ f.path("filterType").asText(null), f.path("filter").asText(null))));
+ t.setImageTagMutabilityExclusionFilters(filters);
+ }
+ t.setRepositoryPolicy(request.path("repositoryPolicy").asText(null));
+ t.setLifecyclePolicy(request.path("lifecyclePolicy").asText(null));
+ if (request.path("appliedFor").isArray()) {
+ t.setAppliedFor(parseStringList(request.path("appliedFor")));
+ }
+ t.setCustomRoleArn(request.path("customRoleArn").asText(null));
+ return t;
+ }
+
+ private ObjectNode buildTemplate(RepositoryCreationTemplate t) {
+ ObjectNode n = objectMapper.createObjectNode();
+ n.put("prefix", t.getPrefix());
+ if (t.getDescription() != null) {
+ n.put("description", t.getDescription());
+ }
+ if (t.getEncryptionConfiguration() != null) {
+ ObjectNode enc = n.putObject("encryptionConfiguration");
+ enc.put("encryptionType", t.getEncryptionConfiguration().encryptionType());
+ if (t.getEncryptionConfiguration().kmsKey() != null) {
+ enc.put("kmsKey", t.getEncryptionConfiguration().kmsKey());
+ }
+ }
+ ArrayNode tags = n.putArray("resourceTags");
+ if (t.getResourceTags() != null) {
+ t.getResourceTags().forEach(tag -> tags.addObject().put("Key", tag.key()).put("Value", tag.value()));
+ }
+ if (t.getImageTagMutability() != null) {
+ n.put("imageTagMutability", t.getImageTagMutability());
+ }
+ if (t.getImageTagMutabilityExclusionFilters() != null && !t.getImageTagMutabilityExclusionFilters().isEmpty()) {
+ ArrayNode filters = n.putArray("imageTagMutabilityExclusionFilters");
+ t.getImageTagMutabilityExclusionFilters().forEach(f -> filters.addObject()
+ .put("filterType", f.filterType()).put("filter", f.filter()));
+ }
+ if (t.getRepositoryPolicy() != null) {
+ n.put("repositoryPolicy", t.getRepositoryPolicy());
+ }
+ if (t.getLifecyclePolicy() != null) {
+ n.put("lifecyclePolicy", t.getLifecyclePolicy());
+ }
+ ArrayNode appliedFor = n.putArray("appliedFor");
+ if (t.getAppliedFor() != null) {
+ t.getAppliedFor().forEach(appliedFor::add);
+ }
+ if (t.getCustomRoleArn() != null) {
+ n.put("customRoleArn", t.getCustomRoleArn());
+ }
+ n.put("createdAt", t.getCreatedAt().getEpochSecond());
+ n.put("updatedAt", t.getUpdatedAt().getEpochSecond());
+ return n;
+ }
+
private static List<String> parseStringList(JsonNode node) {
if (node == null || node.isMissingNode() || node.isNull() || !node.isArray()) {
return new ArrayList<>();
diff --git a/src/main/java/io/github/hectorvent/floci/services/ecr/EcrService.java b/src/main/java/io/github/hectorvent/floci/services/ecr/EcrService.java
index 1da5dddc41..4081963e67 100644
--- a/src/main/java/io/github/hectorvent/floci/services/ecr/EcrService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/ecr/EcrService.java
@@ -1,8 +1,11 @@
package io.github.hectorvent.floci.services.ecr;
+import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.ObjectReader;
import io.github.hectorvent.floci.config.EmulatorConfig;
import io.github.hectorvent.floci.core.common.AwsArnUtils;
import io.github.hectorvent.floci.core.common.AwsException;
@@ -27,6 +30,7 @@ import io.github.hectorvent.floci.services.ecr.model.ImageMetadata;
import io.github.hectorvent.floci.services.ecr.model.PullThroughCacheRule;
import io.github.hectorvent.floci.services.ecr.model.RegistrySettings;
import io.github.hectorvent.floci.services.ecr.model.Repository;
+import io.github.hectorvent.floci.services.ecr.model.RepositoryCreationTemplate;
import io.github.hectorvent.floci.services.ecr.registry.EcrRegistryManager;
import io.github.hectorvent.floci.services.ecr.registry.RegistryHttpClient;
import jakarta.enterprise.context.ApplicationScoped;
@@ -38,6 +42,7 @@ import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Base64;
+import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@@ -76,6 +81,8 @@ public class EcrService implements ResourceProvider {
"ecr", "ecr-public", "quay", "k8s", "docker-hub",
"github-container-registry", "azure-container-registry",
"gitlab-container-registry", "chainguard");
+ private static final ObjectReader SINGLE_JSON_VALUE =
+ MAPPER.reader().with(DeserializationFeature.FAIL_ON_TRAILING_TOKENS);
private static final int MAX_REPO_NAME_LENGTH = 256;
private static final int MAX_PULL_THROUGH_CACHE_PREFIX_LENGTH = 30;
@@ -83,7 +90,8 @@ public class EcrService implements ResourceProvider {
private final StorageBackend<String, ImageMetadata> imageMetaStore;
private final StorageBackend<String, PullThroughCacheRule> pullThroughCacheRuleStore;
private final StorageBackend<String, RegistrySettings> registrySettingsStore;
- private final Map<String, Object> registrySettingsLocks = new ConcurrentHashMap<>();
+ private final Map<String, Object> registryLocks = new ConcurrentHashMap<>();
+ private final StorageBackend<String, RepositoryCreationTemplate> templateStore;
private final EcrRegistryManager registryManager;
private final EmulatorConfig config;
private final RegionResolver regionResolver;
@@ -103,6 +111,8 @@ public class EcrService implements ResourceProvider {
new TypeReference<Map<String, PullThroughCacheRule>>() {}),
factory.create("ecr", "registry-settings.json",
new TypeReference<Map<String, RegistrySettings>>() {}),
+ factory.create("ecr", "repository-creation-templates.json",
+ new TypeReference<Map<String, RepositoryCreationTemplate>>() {}),
registryManager, config, regionResolver);
}
@@ -112,7 +122,7 @@ public class EcrService implements ResourceProvider {
EcrRegistryManager registryManager,
EmulatorConfig config,
RegionResolver regionResolver) {
- this(repoStore, imageMetaStore, pullThroughCacheRuleStore, new InMemoryStorage<>(),
+ this(repoStore, imageMetaStore, pullThroughCacheRuleStore, new InMemoryStorage<>(), new InMemoryStorage<>(),
registryManager, config, regionResolver);
}
@@ -120,6 +130,7 @@ public class EcrService implements ResourceProvider {
StorageBackend<String, ImageMetadata> imageMetaStore,
StorageBackend<String, PullThroughCacheRule> pullThroughCacheRuleStore,
StorageBackend<String, RegistrySettings> registrySettingsStore,
+ StorageBackend<String, RepositoryCreationTemplate> templateStore,
EcrRegistryManager registryManager,
EmulatorConfig config,
RegionResolver regionResolver) {
@@ -127,6 +138,7 @@ public class EcrService implements ResourceProvider {
this.imageMetaStore = imageMetaStore;
this.pullThroughCacheRuleStore = pullThroughCacheRuleStore;
this.registrySettingsStore = registrySettingsStore;
+ this.templateStore = templateStore;
this.registryManager = registryManager;
this.config = config;
this.regionResolver = regionResolver;
@@ -324,6 +336,181 @@ public class EcrService implements ResourceProvider {
}
}
+ // ============================================================
+ // Repository creation templates
+ // ============================================================
+
+ /**
+ * Stores a template under its prefix. Fields left null take ECR's defaults: AES256 encryption
+ * and mutable tags.
+ */
+ public RepositoryCreationTemplate createRepositoryCreationTemplate(RepositoryCreationTemplate requested,
+ String region) {
+ validateTemplateFields(requested);
+ String account = regionResolver.getAccountId();
+ String key = templateKey(region, account, requested.getPrefix());
+ synchronized (registryLock(region)) {
+ if (templateStore.get(key).isPresent()) {
+ throw new AwsException("TemplateAlreadyExistsException",
+ "The repository creation template with prefix '" + requested.getPrefix()
+ + "' already exists in the registry with id '" + account + "'", 400);
+ }
+ RepositoryCreationTemplate template = new RepositoryCreationTemplate();
+ template.setPrefix(requested.getPrefix());
+ template.setEncryptionConfiguration(new RepositoryCreationTemplate.EncryptionConfiguration("AES256", null));
+ template.setImageTagMutability("MUTABLE");
+ applyTemplateFields(template, requested);
+ Instant now = Instant.now();
+ template.setCreatedAt(now);
+ template.setUpdatedAt(now);
+ templateStore.put(key, template);
+ return template;
+ }
+ }
+
+ /**
+ * Every template in the account and Region, or those named in {@code prefixes}; a prefix with
+ * no template is left out, as the model lists no not-found error for this action.
+ */
+ public PaginatedResult<RepositoryCreationTemplate> describeRepositoryCreationTemplates(
+ List<String> prefixes, Integer maxResults, String nextToken, String region) {
+ String account = regionResolver.getAccountId();
+ List<RepositoryCreationTemplate> templates;
+ if (prefixes == null || prefixes.isEmpty()) {
+ String keyPrefix = region + "::" + account + "::";
+ templates = templateStore.scan(key -> key.startsWith(keyPrefix));
+ } else {
+ Set<String> keys = new LinkedHashSet<>();
+ for (String prefix : prefixes) {
+ keys.add(templateKey(region, account, prefix));
+ }
+ templates = new ArrayList<>();
+ for (String key : keys) {
+ templateStore.get(key).ifPresent(templates::add);
+ }
+ }
+ return Pagination.paginate(templates, RepositoryCreationTemplate::getPrefix,
+ maxResults, nextToken, 100, 1000, "InvalidParameterException");
+ }
+
+ /** Replaces each field the request sets; an empty string or list clears it. */
+ public RepositoryCreationTemplate updateRepositoryCreationTemplate(RepositoryCreationTemplate requested,
+ String region) {
+ validateTemplateFields(requested);
+ String key = templateKey(region, regionResolver.getAccountId(), requested.getPrefix());
+ synchronized (registryLock(region)) {
+ RepositoryCreationTemplate template = templateStore.get(key)
+ .orElseThrow(() -> templateNotFound(requested.getPrefix()));
+ applyTemplateFields(template, requested);
+ // Exclusion filters mean nothing outside a *_WITH_EXCLUSION mode. Terraform leaves the
+ // member out when the filters are removed, so they go when the mode no longer takes them.
+ if (!template.getImageTagMutability().endsWith("_WITH_EXCLUSION")) {
+ template.setImageTagMutabilityExclusionFilters(null);
+ }
+ template.setUpdatedAt(Instant.now());
+ templateStore.put(key, template);
+ return template;
+ }
+ }
+
+ public RepositoryCreationTemplate deleteRepositoryCreationTemplate(String prefix, String region) {
+ String key = templateKey(region, regionResolver.getAccountId(), prefix);
+ synchronized (registryLock(region)) {
+ RepositoryCreationTemplate template = templateStore.get(key).orElseThrow(() -> templateNotFound(prefix));
+ templateStore.delete(key);
+ return template;
+ }
+ }
+
+ /** The registry the templates belong to: the caller's account. */
+ public String templateRegistryId() {
+ return regionResolver.getAccountId();
+ }
+
+ /**
+ * The template rules the ECR model can't state; {@code EcrRequestShapes} has already checked
+ * the request against the model's types, lengths, patterns and enums.
+ */
+ private static void validateTemplateFields(RepositoryCreationTemplate t) {
+ if (t.getAppliedFor() != null && t.getAppliedFor().isEmpty()) {
+ throw invalidTemplate("appliedFor must name at least one of REPLICATION, PULL_THROUGH_CACHE "
+ + "or CREATE_ON_PUSH");
+ }
+ requireJsonObject(t.getRepositoryPolicy(), "repositoryPolicy");
+ requireJsonObject(t.getLifecyclePolicy(), "lifecyclePolicy");
+ }
+
+ private static void requireJsonObject(String text, String field) {
+ if (text == null || text.isEmpty()) {
+ return;
+ }
+ if (!isJsonObject(text)) {
+ throw invalidTemplate(field + " must be a JSON object");
+ }
+ }
+
+ /** Whether {@code text} is one JSON object with nothing after it, so {@code {} x} is not. */
+ private static boolean isJsonObject(String text) {
+ try {
+ return SINGLE_JSON_VALUE.readTree(text).isObject();
+ } catch (JsonProcessingException e) {
+ return false;
+ }
+ }
+
+ /** Copies the fields the request sets; an empty string or list clears the stored value. */
+ private static void applyTemplateFields(RepositoryCreationTemplate template, RepositoryCreationTemplate requested) {
+ if (requested.getDescription() != null) {
+ template.setDescription(emptyToNull(requested.getDescription()));
+ }
+ if (requested.getEncryptionConfiguration() != null) {
+ RepositoryCreationTemplate.EncryptionConfiguration e = requested.getEncryptionConfiguration();
+ template.setEncryptionConfiguration(new RepositoryCreationTemplate.EncryptionConfiguration(
+ e.encryptionType(), emptyToNull(e.kmsKey())));
+ }
+ if (requested.getResourceTags() != null) {
+ template.setResourceTags(List.copyOf(requested.getResourceTags()));
+ }
+ if (requested.getImageTagMutability() != null) {
+ template.setImageTagMutability(requested.getImageTagMutability());
+ }
+ if (requested.getImageTagMutabilityExclusionFilters() != null) {
+ template.setImageTagMutabilityExclusionFilters(List.copyOf(requested.getImageTagMutabilityExclusionFilters()));
+ }
+ if (requested.getRepositoryPolicy() != null) {
+ template.setRepositoryPolicy(emptyToNull(requested.getRepositoryPolicy()));
+ }
+ if (requested.getLifecyclePolicy() != null) {
+ template.setLifecyclePolicy(emptyToNull(requested.getLifecyclePolicy()));
+ }
+ if (requested.getAppliedFor() != null) {
+ template.setAppliedFor(List.copyOf(new LinkedHashSet<>(requested.getAppliedFor())));
+ }
+ if (requested.getCustomRoleArn() != null) {
+ template.setCustomRoleArn(emptyToNull(requested.getCustomRoleArn()));
+ }
+ }
+
+ private static String emptyToNull(String value) {
+ return value == null || value.isEmpty() ? null : value;
+ }
+
+ /** ECR assumes a {@code /} after every prefix, so {@code prod} and {@code prod/} are one template. */
+ private static String templateKey(String region, String account, String prefix) {
+ String namespace = prefix.endsWith("/") ? prefix.substring(0, prefix.length() - 1) : prefix;
+ return region + "::" + account + "::" + namespace;
+ }
+
+ private static AwsException invalidTemplate(String message) {
+ return new AwsException("InvalidParameterException", message, 400);
+ }
+
+ private AwsException templateNotFound(String prefix) {
+ return new AwsException("TemplateNotFoundException",
+ "The repository creation template with prefix '" + prefix
+ + "' does not exist in the registry with id '" + regionResolver.getAccountId() + "'", 400);
+ }
+
// ============================================================
// CreateRepository
// ============================================================
@@ -1040,13 +1227,7 @@ public class EcrService implements ResourceProvider {
* text that is not a JSON object is refused here, as the model cannot say so.
*/
public String putRegistryPolicy(String policyText, String region) {
- JsonNode parsed;
- try {
- parsed = policyText == null ? null : MAPPER.readTree(policyText);
- } catch (Exception e) {
- parsed = null;
- }
- if (parsed == null || !parsed.isObject()) {
+ if (policyText == null || !isJsonObject(policyText)) {
throw new AwsException("InvalidParameterException", "Invalid parameter at 'PolicyText' failed to satisfy "
+ "constraint: 'Invalid registry policy provided'", 400);
}
@@ -1145,7 +1326,7 @@ public class EcrService implements ResourceProvider {
*/
private <T> T updateRegistrySettings(String region, Function<RegistrySettings, T> change) {
String key = registrySettingsKey(region);
- synchronized (registrySettingsLocks.computeIfAbsent(key, k -> new Object())) {
+ synchronized (registryLock(region)) {
RegistrySettings settings = registrySettings(region);
T result = change.apply(settings);
registrySettingsStore.put(key, settings);
@@ -1153,6 +1334,15 @@ public class EcrService implements ResourceProvider {
}
}
+ /**
+ * One lock per registry for every read and write back of its settings and creation templates:
+ * unlocked, two creates of one template prefix could both succeed, and an update could write
+ * back a template a delete had just removed.
+ */
+ private Object registryLock(String region) {
+ return registryLocks.computeIfAbsent(registrySettingsKey(region), k -> new Object());
+ }
+
private String registrySettingsKey(String region) {
return region + "::" + regionResolver.getAccountId();
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/ecr/model/RepositoryCreationTemplate.java b/src/main/java/io/github/hectorvent/floci/services/ecr/model/RepositoryCreationTemplate.java
new file mode 100644
index 0000000000..971d69641d
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/ecr/model/RepositoryCreationTemplate.java
@@ -0,0 +1,82 @@
+package io.github.hectorvent.floci.services.ecr.model;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.time.Instant;
+import java.util.List;
+
+/**
+ * A repository creation template: the settings ECR gives a repository it creates for a
+ * replication, pull through cache or create-on-push rule whose name starts with the template's
+ * prefix. Floci records templates; nothing in Floci creates repositories that would use them.
+ */
+@RegisterForReflection
+public class RepositoryCreationTemplate {
+
+ /** The encryption a created repository gets. */
+ @RegisterForReflection
+ public record EncryptionConfiguration(String encryptionType, String kmsKey) {}
+
+ /** One tag a created repository gets. */
+ @RegisterForReflection
+ public record ResourceTag(String key, String value) {}
+
+ /** One tag filter exempt from the template's tag mutability setting. */
+ @RegisterForReflection
+ public record ExclusionFilter(String filterType, String filter) {}
+
+ private String prefix;
+ private String description;
+ private EncryptionConfiguration encryptionConfiguration;
+ private List<ResourceTag> resourceTags;
+ private String imageTagMutability;
+ private List<ExclusionFilter> imageTagMutabilityExclusionFilters;
+ private String repositoryPolicy;
+ private String lifecyclePolicy;
+ private List<String> appliedFor;
+ private String customRoleArn;
+ private Instant createdAt;
+ private Instant updatedAt;
+
+ public RepositoryCreationTemplate() {}
+
+ public String getPrefix() { return prefix; }
+ public void setPrefix(String prefix) { this.prefix = prefix; }
+
+ public String getDescription() { return description; }
+ public void setDescription(String description) { this.description = description; }
+
+ public EncryptionConfiguration getEncryptionConfiguration() { return encryptionConfiguration; }
+ public void setEncryptionConfiguration(EncryptionConfiguration encryptionConfiguration) {
+ this.encryptionConfiguration = encryptionConfiguration;
+ }
+
+ public List<ResourceTag> getResourceTags() { return resourceTags; }
+ public void setResourceTags(List<ResourceTag> resourceTags) { this.resourceTags = resourceTags; }
+
+ public String getImageTagMutability() { return imageTagMutability; }
+ public void setImageTagMutability(String imageTagMutability) { this.imageTagMutability = imageTagMutability; }
+
+ public List<ExclusionFilter> getImageTagMutabilityExclusionFilters() { return imageTagMutabilityExclusionFilters; }
+ public void setImageTagMutabilityExclusionFilters(List<ExclusionFilter> imageTagMutabilityExclusionFilters) {
+ this.imageTagMutabilityExclusionFilters = imageTagMutabilityExclusionFilters;
+ }
+
+ public String getRepositoryPolicy() { return repositoryPolicy; }
+ public void setRepositoryPolicy(String repositoryPolicy) { this.repositoryPolicy = repositoryPolicy; }
+
+ public String getLifecyclePolicy() { return lifecyclePolicy; }
+ public void setLifecyclePolicy(String lifecyclePolicy) { this.lifecyclePolicy = lifecyclePolicy; }
+
+ public List<String> getAppliedFor() { return appliedFor; }
+ public void setAppliedFor(List<String> appliedFor) { this.appliedFor = appliedFor; }
+
+ public String getCustomRoleArn() { return customRoleArn; }
+ public void setCustomRoleArn(String customRoleArn) { this.customRoleArn = customRoleArn; }
+
+ public Instant getCreatedAt() { return createdAt; }
+ public void setCreatedAt(Instant createdAt) { this.createdAt = createdAt; }
+
+ public Instant getUpdatedAt() { return updatedAt; }
+ public void setUpdatedAt(Instant updatedAt) { this.updatedAt = updatedAt; }
+}
diff --git a/src/main/resources/aws/ecr-request-shapes.json b/src/main/resources/aws/ecr-request-shapes.json
index b38304d432..6f4ec57b31 100644
--- a/src/main/resources/aws/ecr-request-shapes.json
+++ b/src/main/resources/aws/ecr-request-shapes.json
@@ -11,7 +11,11 @@
"DescribeRegistry": "DescribeRegistryRequest",
"PutRegistryScanningConfiguration": "PutRegistryScanningConfigurationRequest",
"GetRegistryScanningConfiguration": "GetRegistryScanningConfigurationRequest",
- "BatchGetRepositoryScanningConfiguration": "BatchGetRepositoryScanningConfigurationRequest"
+ "BatchGetRepositoryScanningConfiguration": "BatchGetRepositoryScanningConfigurationRequest",
+ "CreateRepositoryCreationTemplate": "CreateRepositoryCreationTemplateRequest",
+ "UpdateRepositoryCreationTemplate": "UpdateRepositoryCreationTemplateRequest",
+ "DescribeRepositoryCreationTemplates": "DescribeRepositoryCreationTemplatesRequest",
+ "DeleteRepositoryCreationTemplate": "DeleteRepositoryCreationTemplateRequest"
},
"shapes": {
"BatchGetRepositoryScanningConfigurationRequest": {
@@ -23,14 +27,72 @@
"repositoryNames": "ScanningConfigurationRepositoryNameList"
}
},
+ "CreateRepositoryCreationTemplateRequest": {
+ "type": "structure",
+ "required": [
+ "prefix",
+ "appliedFor"
+ ],
+ "members": {
+ "prefix": "Prefix",
+ "description": "RepositoryTemplateDescription",
+ "encryptionConfiguration": "EncryptionConfigurationForRepositoryCreationTemplate",
+ "resourceTags": "TagList",
+ "imageTagMutability": "ImageTagMutability",
+ "imageTagMutabilityExclusionFilters": "ImageTagMutabilityExclusionFilters",
+ "repositoryPolicy": "RepositoryPolicyText",
+ "lifecyclePolicy": "LifecyclePolicyTextForRepositoryCreationTemplate",
+ "appliedFor": "RCTAppliedForList",
+ "customRoleArn": "CustomRoleArn"
+ }
+ },
+ "CustomRoleArn": {
+ "type": "string",
+ "max": 2048
+ },
"DeleteRegistryPolicyRequest": {
"type": "structure",
"members": {}
},
+ "DeleteRepositoryCreationTemplateRequest": {
+ "type": "structure",
+ "required": [
+ "prefix"
+ ],
+ "members": {
+ "prefix": "Prefix"
+ }
+ },
"DescribeRegistryRequest": {
"type": "structure",
"members": {}
},
+ "DescribeRepositoryCreationTemplatesRequest": {
+ "type": "structure",
+ "members": {
+ "prefixes": "PrefixList",
+ "nextToken": "NextToken",
+ "maxResults": "MaxResults"
+ }
+ },
+ "EncryptionConfigurationForRepositoryCreationTemplate": {
+ "type": "structure",
+ "required": [
+ "encryptionType"
+ ],
+ "members": {
+ "encryptionType": "EncryptionType",
+ "kmsKey": "KmsKeyForRepositoryCreationTemplate"
+ }
+ },
+ "EncryptionType": {
+ "type": "string",
+ "enum": [
+ "AES256",
+ "KMS",
+ "KMS_DSSE"
+ ]
+ },
"GetRegistryPolicyRequest": {
"type": "structure",
"members": {}
@@ -39,6 +101,73 @@
"type": "structure",
"members": {}
},
+ "ImageTagMutability": {
+ "type": "string",
+ "enum": [
+ "MUTABLE",
+ "IMMUTABLE",
+ "IMMUTABLE_WITH_EXCLUSION",
+ "MUTABLE_WITH_EXCLUSION"
+ ]
+ },
+ "ImageTagMutabilityExclusionFilter": {
+ "type": "structure",
+ "required": [
+ "filterType",
+ "filter"
+ ],
+ "members": {
+ "filterType": "ImageTagMutabilityExclusionFilterType",
+ "filter": "ImageTagMutabilityExclusionFilterValue"
+ }
+ },
+ "ImageTagMutabilityExclusionFilterType": {
+ "type": "string",
+ "enum": [
+ "WILDCARD"
+ ]
+ },
+ "ImageTagMutabilityExclusionFilterValue": {
+ "type": "string",
+ "min": 1,
+ "max": 128,
+ "pattern": "^[0-9a-zA-Z._*-]{1,128}$"
+ },
+ "ImageTagMutabilityExclusionFilters": {
+ "type": "list",
+ "min": 1,
+ "max": 5,
+ "member": "ImageTagMutabilityExclusionFilter"
+ },
+ "KmsKeyForRepositoryCreationTemplate": {
+ "type": "string",
+ "min": 0,
+ "max": 2048,
+ "pattern": "^$|arn:aws[a-z0-9-]*:kms:[a-z0-9-]+:[0-9]{12}:key\\/[a-z0-9-]+"
+ },
+ "LifecyclePolicyTextForRepositoryCreationTemplate": {
+ "type": "string",
+ "min": 0,
+ "max": 30720
+ },
+ "MaxResults": {
+ "type": "integer",
+ "min": 1,
+ "max": 1000
+ },
+ "NextToken": {
+ "type": "string"
+ },
+ "Prefix": {
+ "type": "string",
+ "min": 1,
+ "max": 256,
+ "pattern": "^([a-z0-9]+((\\.|_|__|-+)[a-z0-9]+)*(\\/[a-z0-9]+((\\.|_|__|-+)[a-z0-9]+)*)*\\/?|ROOT)$"
+ },
+ "PrefixList": {
+ "type": "list",
+ "member": "Prefix"
+ },
"PutRegistryPolicyRequest": {
"type": "structure",
"required": [
@@ -64,6 +193,18 @@
"replicationConfiguration": "ReplicationConfiguration"
}
},
+ "RCTAppliedFor": {
+ "type": "string",
+ "enum": [
+ "REPLICATION",
+ "PULL_THROUGH_CACHE",
+ "CREATE_ON_PUSH"
+ ]
+ },
+ "RCTAppliedForList": {
+ "type": "list",
+ "member": "RCTAppliedFor"
+ },
"Region": {
"type": "string",
"min": 2,
@@ -173,6 +314,15 @@
"max": 256,
"pattern": "[a-z0-9]+((\\.|_|__|-+)[a-z0-9]+)*(\\/[a-z0-9]+((\\.|_|__|-+)[a-z0-9]+)*)*"
},
+ "RepositoryPolicyText": {
+ "type": "string",
+ "min": 0,
+ "max": 10240
+ },
+ "RepositoryTemplateDescription": {
+ "type": "string",
+ "max": 256
+ },
"ScanFrequency": {
"type": "string",
"enum": [
@@ -222,6 +372,45 @@
"min": 1,
"max": 255,
"pattern": "^[a-z0-9*](?:[._\\-/a-z0-9*]?[a-z0-9*]+)*$"
+ },
+ "Tag": {
+ "type": "structure",
+ "required": [
+ "Key",
+ "Value"
+ ],
+ "members": {
+ "Key": "TagKey",
+ "Value": "TagValue"
+ }
+ },
+ "TagKey": {
+ "type": "string"
+ },
+ "TagList": {
+ "type": "list",
+ "member": "Tag"
+ },
+ "TagValue": {
+ "type": "string"
+ },
+ "UpdateRepositoryCreationTemplateRequest": {
+ "type": "structure",
+ "required": [
+ "prefix"
+ ],
+ "members": {
+ "prefix": "Prefix",
+ "description": "RepositoryTemplateDescription",
+ "encryptionConfiguration": "EncryptionConfigurationForRepositoryCreationTemplate",
+ "resourceTags": "TagList",
+ "imageTagMutability": "ImageTagMutability",
+ "imageTagMutabilityExclusionFilters": "ImageTagMutabilityExclusionFilters",
+ "repositoryPolicy": "RepositoryPolicyText",
+ "lifecyclePolicy": "LifecyclePolicyTextForRepositoryCreationTemplate",
+ "appliedFor": "RCTAppliedForList",
+ "customRoleArn": "CustomRoleArn"
+ }
}
}
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ecr/EcrRepositoryCreationTemplatesIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/ecr/EcrRepositoryCreationTemplatesIntegrationTest.java
new file mode 100644
index 0000000000..820be92903
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/ecr/EcrRepositoryCreationTemplatesIntegrationTest.java
@@ -0,0 +1,129 @@
+package io.github.hectorvent.floci.services.ecr;
+
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.response.ValidatableResponse;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.Matchers.nullValue;
+
+/**
+ * Repository creation templates over the JSON protocol. Each test uses its own Region so they do
+ * not share state.
+ */
+@QuarkusTest
+class EcrRepositoryCreationTemplatesIntegrationTest {
+
+ private static final String CT = "application/x-amz-json-1.1";
+ private static final String PREFIX = "AmazonEC2ContainerRegistry_V20150921.";
+ private static final String POLICY = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Sid\":\"Pull\","
+ + "\"Effect\":\"Allow\",\"Principal\":\"*\",\"Action\":[\"ecr:BatchGetImage\"]}]}";
+
+ @BeforeAll
+ static void configureRestAssured() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ @Test
+ void aTemplateIsCreatedDescribedUpdatedAndDeleted() {
+ String region = "eu-north-1";
+ call("CreateRepositoryCreationTemplate", "{\"prefix\":\"prod\",\"description\":\"production\","
+ + "\"appliedFor\":[\"PULL_THROUGH_CACHE\",\"REPLICATION\"],"
+ + "\"resourceTags\":[{\"Key\":\"team\",\"Value\":\"platform\"}],"
+ + "\"imageTagMutability\":\"IMMUTABLE_WITH_EXCLUSION\","
+ + "\"imageTagMutabilityExclusionFilters\":[{\"filterType\":\"WILDCARD\",\"filter\":\"latest*\"}],"
+ + "\"repositoryPolicy\":" + quote(POLICY) + "}", region).statusCode(200)
+ .body("registryId", equalTo("000000000000"))
+ .body("repositoryCreationTemplate.prefix", equalTo("prod"))
+ .body("repositoryCreationTemplate.encryptionConfiguration.encryptionType", equalTo("AES256"))
+ .body("repositoryCreationTemplate.resourceTags[0].Key", equalTo("team"))
+ .body("repositoryCreationTemplate.imageTagMutabilityExclusionFilters[0].filter", equalTo("latest*"))
+ .body("repositoryCreationTemplate.repositoryPolicy", equalTo(POLICY))
+ .body("repositoryCreationTemplate.createdAt", notNullValue());
+ call("CreateRepositoryCreationTemplate", "{\"prefix\":\"prod\",\"appliedFor\":[\"REPLICATION\"]}", region)
+ .statusCode(400).body("__type", equalTo("TemplateAlreadyExistsException"));
+
+ call("DescribeRepositoryCreationTemplates", "{\"prefixes\":[\"prod\",\"absent\"]}", region).statusCode(200)
+ .body("registryId", equalTo("000000000000"))
+ .body("repositoryCreationTemplates", hasSize(1))
+ .body("repositoryCreationTemplates[0].description", equalTo("production"))
+ .body("repositoryCreationTemplates[0].appliedFor", contains("PULL_THROUGH_CACHE", "REPLICATION"));
+
+ call("UpdateRepositoryCreationTemplate", "{\"prefix\":\"prod\",\"description\":\"\","
+ + "\"encryptionConfiguration\":{\"encryptionType\":\"KMS\"},\"appliedFor\":[\"CREATE_ON_PUSH\"]}",
+ region).statusCode(200)
+ .body("repositoryCreationTemplate.description", nullValue())
+ .body("repositoryCreationTemplate.encryptionConfiguration.encryptionType", equalTo("KMS"))
+ .body("repositoryCreationTemplate.appliedFor", contains("CREATE_ON_PUSH"))
+ .body("repositoryCreationTemplate.repositoryPolicy", equalTo(POLICY));
+
+ call("DeleteRepositoryCreationTemplate", "{\"prefix\":\"prod\"}", region).statusCode(200)
+ .body("repositoryCreationTemplate.prefix", equalTo("prod"));
+ call("DeleteRepositoryCreationTemplate", "{\"prefix\":\"prod\"}", region).statusCode(400)
+ .body("__type", equalTo("TemplateNotFoundException"));
+ call("UpdateRepositoryCreationTemplate", "{\"prefix\":\"prod\",\"description\":\"x\"}", region)
+ .statusCode(400).body("__type", equalTo("TemplateNotFoundException"));
+ }
+
+ @Test
+ void templatesPageInPrefixOrder() {
+ String region = "eu-south-1";
+ for (String prefix : new String[] {"ROOT", "apps/web", "apps"}) {
+ call("CreateRepositoryCreationTemplate", "{\"prefix\":\"" + prefix
+ + "\",\"appliedFor\":[\"REPLICATION\"]}", region).statusCode(200);
+ }
+ String token = call("DescribeRepositoryCreationTemplates", "{\"maxResults\":2}", region).statusCode(200)
+ .body("repositoryCreationTemplates.prefix", contains("ROOT", "apps"))
+ .extract().path("nextToken");
+ call("DescribeRepositoryCreationTemplates", "{\"maxResults\":2,\"nextToken\":\"" + token + "\"}", region)
+ .statusCode(200)
+ .body("repositoryCreationTemplates.prefix", contains("apps/web"))
+ .body("nextToken", nullValue());
+ }
+
+ @Test
+ void badInputIsAnInvalidParameter() {
+ String region = "ap-south-2";
+ for (String body : new String[] {
+ "{\"prefix\":\"prod\"}",
+ "{\"prefix\":\"Prod\",\"appliedFor\":[\"REPLICATION\"]}",
+ "{\"prefix\":\"prod\",\"appliedFor\":[\"SOMETIMES\"]}",
+ "{\"prefix\":\"prod\",\"appliedFor\":[\"REPLICATION\"],\"imageTagMutability\":\"FROZEN\"}",
+ "{\"prefix\":\"prod\",\"appliedFor\":[\"REPLICATION\"],\"lifecyclePolicy\":\"not json\"}",
+ "{\"prefix\":\"prod\",\"appliedFor\":[\"REPLICATION\"],"
+ + "\"encryptionConfiguration\":{\"encryptionType\":\"KMS\",\"kmsKey\":\"alias/x\"}}"}) {
+ call("CreateRepositoryCreationTemplate", body, region).statusCode(400)
+ .body("__type", equalTo("InvalidParameterException"));
+ }
+ // The handler checks the request against the vendored model before the service sees it.
+ call("CreateRepositoryCreationTemplate", "{\"prefix\":\"prod\"}", region).statusCode(400)
+ .body("message", equalTo("Invalid parameter at 'appliedFor' failed to satisfy constraint: "
+ + "'Member must not be null'"));
+ call("DescribeRepositoryCreationTemplates", "{\"maxResults\":0}", region).statusCode(400)
+ .body("__type", equalTo("InvalidParameterException"));
+ call("DescribeRepositoryCreationTemplates", "{}", region).statusCode(200)
+ .body("repositoryCreationTemplates", hasSize(0));
+ }
+
+ private static String quote(String text) {
+ return "\"" + text.replace("\\", "\\\\").replace("\"", "\\\"") + "\"";
+ }
+
+ private static ValidatableResponse call(String action, String body, String region) {
+ return given()
+ .header("X-Amz-Target", PREFIX + action)
+ .header("Authorization", "AWS4-HMAC-SHA256 Credential=000000000000/20261016/" + region
+ + "/ecr/aws4_request, SignedHeaders=host, Signature=abc")
+ .contentType(CT)
+ .body(body)
+ .when()
+ .post("/")
+ .then();
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/ecr/EcrRequestShapesTest.java b/src/test/java/io/github/hectorvent/floci/services/ecr/EcrRequestShapesTest.java
index 1ab736f29e..b802d26153 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ecr/EcrRequestShapesTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ecr/EcrRequestShapesTest.java
@@ -122,6 +122,86 @@ class EcrRequestShapesTest {
json("{\"scanType\":\"ENHANCED\",\"rules\":[" + scanRule + "," + scanRule + "]}")));
}
+ private static final String PREFIX_PATTERN =
+ "^([a-z0-9]+((\\.|_|__|-+)[a-z0-9]+)*(\\/[a-z0-9]+((\\.|_|__|-+)[a-z0-9]+)*)*\\/?|ROOT)$";
+
+ private static String template(String fields) {
+ return "{\"prefix\":\"prod\",\"appliedFor\":[\"REPLICATION\"]" + fields + "}";
+ }
+
+ private static String constraint(String member, String rule) {
+ return "Invalid parameter at '" + member + "' failed to satisfy constraint: '" + rule + "'";
+ }
+
+ @Test
+ void creationTemplateFields() {
+ String create = "CreateRepositoryCreationTemplate";
+ assertEquals(constraint("prefix", "must satisfy regular expression '" + PREFIX_PATTERN + "'"),
+ refusal(create, "{\"prefix\":\"Prod\",\"appliedFor\":[\"REPLICATION\"]}"));
+ assertEquals(constraint("prefix", "Member must have length less than or equal to 256"),
+ refusal(create, "{\"prefix\":\"" + "a".repeat(257) + "\",\"appliedFor\":[\"REPLICATION\"]}"));
+ assertEquals(constraint("appliedFor", "Member must not be null"), refusal(create, "{\"prefix\":\"prod\"}"));
+ assertEquals(constraint("appliedFor", "Member must satisfy enum value set: "
+ + "[REPLICATION, PULL_THROUGH_CACHE, CREATE_ON_PUSH]"),
+ refusal(create, "{\"prefix\":\"prod\",\"appliedFor\":[\"PULL\"]}"));
+ assertEquals(constraint("description", "Member must have length less than or equal to 256"),
+ refusal(create, template(",\"description\":\"" + "d".repeat(257) + "\"")));
+ assertEquals(constraint("encryptionConfiguration.encryptionType",
+ "Member must satisfy enum value set: [AES256, KMS, KMS_DSSE]"),
+ refusal(create, template(",\"encryptionConfiguration\":{\"encryptionType\":\"RSA\"}")));
+ assertEquals(constraint("encryptionConfiguration.kmsKey", "must satisfy regular expression "
+ + "'^$|arn:aws[a-z0-9-]*:kms:[a-z0-9-]+:[0-9]{12}:key\\/[a-z0-9-]+'"),
+ refusal(create, template(",\"encryptionConfiguration\":{\"encryptionType\":\"KMS\","
+ + "\"kmsKey\":\"alias/mine\"}")));
+ assertEquals(constraint("imageTagMutability", "Member must satisfy enum value set: "
+ + "[MUTABLE, IMMUTABLE, IMMUTABLE_WITH_EXCLUSION, MUTABLE_WITH_EXCLUSION]"),
+ refusal(create, template(",\"imageTagMutability\":\"FROZEN\"")));
+ assertEquals(constraint("imageTagMutabilityExclusionFilters.filterType",
+ "Member must satisfy enum value set: [WILDCARD]"),
+ refusal(create, template(",\"imageTagMutabilityExclusionFilters\":[{\"filterType\":\"PREFIX_MATCH\","
+ + "\"filter\":\"latest\"}]")));
+ assertEquals(constraint("imageTagMutabilityExclusionFilters.filter",
+ "must satisfy regular expression '^[0-9a-zA-Z._*-]{1,128}$'"),
+ refusal(create, template(",\"imageTagMutabilityExclusionFilters\":[{\"filterType\":\"WILDCARD\","
+ + "\"filter\":\"no spaces\"}]")));
+ String filter = "{\"filterType\":\"WILDCARD\",\"filter\":\"v*\"}";
+ assertEquals(constraint("imageTagMutabilityExclusionFilters", "Member must have length less than or equal to 5"),
+ refusal(create, template(",\"imageTagMutabilityExclusionFilters\":["
+ + String.join(",", Collections.nCopies(6, filter)) + "]")));
+ assertEquals(constraint("resourceTags.Value", "Member must not be null"),
+ refusal(create, template(",\"resourceTags\":[{\"Key\":\"team\"}]")));
+ assertEquals(constraint("repositoryPolicy", "Member must have length less than or equal to 10240"),
+ refusal(create, template(",\"repositoryPolicy\":\"" + "p".repeat(10241) + "\"")));
+ assertEquals(constraint("lifecyclePolicy", "Member must have length less than or equal to 30720"),
+ refusal(create, template(",\"lifecyclePolicy\":\"" + "l".repeat(30721) + "\"")));
+ assertEquals(constraint("customRoleArn", "Member must have length less than or equal to 2048"),
+ refusal(create, template(",\"customRoleArn\":\"" + "r".repeat(2049) + "\"")));
+
+ // The model gives the exclusion filters at least one entry, so an empty list does not clear them.
+ assertEquals(constraint("imageTagMutabilityExclusionFilters",
+ "Member must have length greater than or equal to 1"),
+ refusal("UpdateRepositoryCreationTemplate",
+ "{\"prefix\":\"prod\",\"imageTagMutabilityExclusionFilters\":[]}"));
+ assertEquals(constraint("prefix", "Member must not be null"),
+ refusal("UpdateRepositoryCreationTemplate", "{\"description\":\"x\"}"));
+ assertEquals(constraint("prefixes", "must satisfy regular expression '" + PREFIX_PATTERN + "'"),
+ refusal("DescribeRepositoryCreationTemplates", "{\"prefixes\":[\"Bad\"]}"));
+ assertEquals(constraint("maxResults", "Member must have value less than or equal to 1000"),
+ refusal("DescribeRepositoryCreationTemplates", "{\"maxResults\":1001}"));
+ assertEquals(constraint("prefix", "Member must not be null"), refusal("DeleteRepositoryCreationTemplate", "{}"));
+
+ // Emptying a string clears it, so the model allows it where an update can send one.
+ assertDoesNotThrow(() -> EcrRequestShapes.check("UpdateRepositoryCreationTemplate", json(
+ "{\"prefix\":\"ROOT\",\"description\":\"\",\"repositoryPolicy\":\"\",\"lifecyclePolicy\":\"\","
+ + "\"customRoleArn\":\"\",\"encryptionConfiguration\":{\"encryptionType\":\"KMS\","
+ + "\"kmsKey\":\"\"},\"resourceTags\":[],\"appliedFor\":[]}")));
+ assertDoesNotThrow(() -> EcrRequestShapes.check(create, json(template(
+ ",\"encryptionConfiguration\":{\"encryptionType\":\"KMS_DSSE\",\"kmsKey\":"
+ + "\"arn:aws-us-gov:kms:us-gov-west-1:000000000000:key/1234abcd-12ab\"},"
+ + "\"imageTagMutabilityExclusionFilters\":[" + String.join(",", Collections.nCopies(5, filter))
+ + "],\"resourceTags\":[{\"Key\":\"team\",\"Value\":\"platform\"}]"))));
+ }
+
@Test
void readsTakeAnEmptyBody() {
for (String operation : new String[] {"GetRegistryPolicy", "DeleteRegistryPolicy", "DescribeRegistry",
diff --git a/src/test/java/io/github/hectorvent/floci/services/ecr/EcrServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/ecr/EcrServiceTest.java
index aaecd2232e..1888d8ebc9 100644
--- a/src/test/java/io/github/hectorvent/floci/services/ecr/EcrServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/ecr/EcrServiceTest.java
@@ -15,10 +15,13 @@ import io.github.hectorvent.floci.services.ecr.model.ImageMetadata;
import io.github.hectorvent.floci.services.ecr.model.PullThroughCacheRule;
import io.github.hectorvent.floci.services.ecr.model.RegistrySettings;
import io.github.hectorvent.floci.services.ecr.model.Repository;
+import io.github.hectorvent.floci.services.ecr.model.RepositoryCreationTemplate;
import io.github.hectorvent.floci.services.ecr.registry.EcrRegistryManager;
import io.github.hectorvent.floci.services.ecr.registry.RegistryHttpClient;
+import io.github.hectorvent.floci.testing.ParkingStore;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
import org.mockito.Mockito;
import java.io.IOException;
@@ -31,9 +34,12 @@ import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
@@ -1375,6 +1381,7 @@ class EcrServiceTest {
assertInvalid(() -> service.putRegistryPolicy("not json", REGION));
assertInvalid(() -> service.putRegistryPolicy("[]", REGION));
assertInvalid(() -> service.putRegistryPolicy("", REGION));
+ assertInvalid(() -> service.putRegistryPolicy("{} x", REGION));
}
@Test
@@ -1417,9 +1424,10 @@ class EcrServiceTest {
void registrySettings_areKeptPerAccountAndRegion() {
InMemoryStorage<String, RegistrySettings> store = new InMemoryStorage<>();
EcrService first = new EcrService(new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),
- store, registryManager, Mockito.mock(EmulatorConfig.class), new RegionResolver(REGION, ACCOUNT));
+ store, new InMemoryStorage<>(), registryManager, Mockito.mock(EmulatorConfig.class),
+ new RegionResolver(REGION, ACCOUNT));
EcrService other = new EcrService(new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),
- store, registryManager, Mockito.mock(EmulatorConfig.class),
+ store, new InMemoryStorage<>(), registryManager, Mockito.mock(EmulatorConfig.class),
new RegionResolver(REGION, "111111111111"));
first.putRegistryPolicy(REGISTRY_POLICY, REGION);
@@ -1436,7 +1444,7 @@ class EcrServiceTest {
@Test
void registrySettings_parallelPutsAllSurvive() throws Exception {
EcrService parallel = new EcrService(new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),
- new InMemoryStorage<>(), registryManager, Mockito.mock(EmulatorConfig.class),
+ new InMemoryStorage<>(), new InMemoryStorage<>(), registryManager, Mockito.mock(EmulatorConfig.class),
new RegionResolver(REGION, ACCOUNT));
List<RegistrySettings.ReplicationRule> rules = List.of(replicateTo("eu-west-1", ACCOUNT, null));
ExecutorService pool = Executors.newFixedThreadPool(3);
@@ -1465,4 +1473,230 @@ class EcrServiceTest {
pool.shutdownNow();
}
}
+
+ // ------------------------------------------------------------
+ // Repository creation templates
+ // ------------------------------------------------------------
+
+ private static RepositoryCreationTemplate template(String prefix, String... appliedFor) {
+ RepositoryCreationTemplate t = new RepositoryCreationTemplate();
+ t.setPrefix(prefix);
+ t.setAppliedFor(appliedFor.length == 0 ? null : List.of(appliedFor));
+ return t;
+ }
+
+ private static void assertInvalidTemplate(Executable call) {
+ assertEquals("InvalidParameterException", assertThrows(AwsException.class, call).getErrorCode());
+ }
+
+ @Test
+ void creationTemplate_createsWithDefaultsAndRefusesADuplicate() {
+ RepositoryCreationTemplate created = service.createRepositoryCreationTemplate(
+ template("prod", "PULL_THROUGH_CACHE", "REPLICATION"), REGION);
+
+ assertEquals("prod", created.getPrefix());
+ assertEquals("AES256", created.getEncryptionConfiguration().encryptionType());
+ assertEquals("MUTABLE", created.getImageTagMutability());
+ assertEquals(List.of("PULL_THROUGH_CACHE", "REPLICATION"), created.getAppliedFor());
+ assertNotNull(created.getCreatedAt());
+ assertEquals(created.getCreatedAt(), created.getUpdatedAt());
+
+ AwsException duplicate = assertThrows(AwsException.class,
+ () -> service.createRepositoryCreationTemplate(template("prod", "REPLICATION"), REGION));
+ assertEquals("TemplateAlreadyExistsException", duplicate.getErrorCode());
+ }
+
+ /** The rules the model can't state; the model's own are in {@code EcrRequestShapesTest}. */
+ @Test
+ void creationTemplate_checksWhatTheModelCannotState() {
+ RepositoryCreationTemplate noAppliedFor = template("prod");
+ noAppliedFor.setAppliedFor(List.of());
+ assertInvalidTemplate(() -> service.createRepositoryCreationTemplate(noAppliedFor, REGION));
+ RepositoryCreationTemplate badPolicy = template("prod", "REPLICATION");
+ badPolicy.setRepositoryPolicy("[]");
+ assertInvalidTemplate(() -> service.createRepositoryCreationTemplate(badPolicy, REGION));
+ RepositoryCreationTemplate badLifecycle = template("prod", "REPLICATION");
+ badLifecycle.setLifecyclePolicy("not json");
+ assertInvalidTemplate(() -> service.createRepositoryCreationTemplate(badLifecycle, REGION));
+ // A JSON object followed by more text is still not a JSON object.
+ RepositoryCreationTemplate trailingPolicy = template("prod", "REPLICATION");
+ trailingPolicy.setRepositoryPolicy("{}{}");
+ assertInvalidTemplate(() -> service.createRepositoryCreationTemplate(trailingPolicy, REGION));
+ RepositoryCreationTemplate trailingLifecycle = template("prod", "REPLICATION");
+ trailingLifecycle.setLifecyclePolicy("{\"rules\":[]} []");
+ assertInvalidTemplate(() -> service.createRepositoryCreationTemplate(trailingLifecycle, REGION));
+
+ RepositoryCreationTemplate full = template("ROOT", "CREATE_ON_PUSH");
+ full.setEncryptionConfiguration(new RepositoryCreationTemplate.EncryptionConfiguration("KMS_DSSE",
+ "arn:aws:kms:us-east-1:000000000000:key/1234abcd-12ab-34cd-56ef-1234567890ab"));
+ full.setImageTagMutability("IMMUTABLE_WITH_EXCLUSION");
+ full.setImageTagMutabilityExclusionFilters(
+ List.of(new RepositoryCreationTemplate.ExclusionFilter("WILDCARD", "latest*")));
+ full.setRepositoryPolicy("{\"Version\":\"2012-10-17\",\"Statement\":[]}");
+ full.setLifecyclePolicy("{\"rules\":[]}");
+ assertEquals("KMS_DSSE", service.createRepositoryCreationTemplate(full, REGION)
+ .getEncryptionConfiguration().encryptionType());
+ }
+
+ @Test
+ void creationTemplate_updateReplacesWhatIsSentAndKeepsTheRest() {
+ RepositoryCreationTemplate created = template("team/app", "REPLICATION");
+ created.setDescription("first");
+ created.setRepositoryPolicy("{\"Version\":\"2012-10-17\"}");
+ service.createRepositoryCreationTemplate(created, REGION);
+
+ RepositoryCreationTemplate change = template("team/app");
+ change.setImageTagMutability("IMMUTABLE");
+ change.setRepositoryPolicy("");
+ RepositoryCreationTemplate updated = service.updateRepositoryCreationTemplate(change, REGION);
+
+ assertEquals("first", updated.getDescription());
+ assertEquals(List.of("REPLICATION"), updated.getAppliedFor());
+ assertEquals("IMMUTABLE", updated.getImageTagMutability());
+ assertNull(updated.getRepositoryPolicy());
+
+ RepositoryCreationTemplate badChange = template("team/app");
+ badChange.setAppliedFor(List.of());
+ assertInvalidTemplate(() -> service.updateRepositoryCreationTemplate(badChange, REGION));
+ assertEquals("TemplateNotFoundException", assertThrows(AwsException.class,
+ () -> service.updateRepositoryCreationTemplate(template("other"), REGION)).getErrorCode());
+ }
+
+ @Test
+ void creationTemplate_filtersGoWhenAnUpdateLeavesAnExclusionMode() {
+ RepositoryCreationTemplate created = template("team/app", "REPLICATION");
+ created.setImageTagMutability("IMMUTABLE_WITH_EXCLUSION");
+ created.setImageTagMutabilityExclusionFilters(
+ List.of(new RepositoryCreationTemplate.ExclusionFilter("WILDCARD", "latest*")));
+ service.createRepositoryCreationTemplate(created, REGION);
+
+ RepositoryCreationTemplate otherMode = template("team/app");
+ otherMode.setImageTagMutability("MUTABLE_WITH_EXCLUSION");
+ assertEquals(1, service.updateRepositoryCreationTemplate(otherMode, REGION)
+ .getImageTagMutabilityExclusionFilters().size(), "an exclusion mode keeps them");
+
+ RepositoryCreationTemplate plain = template("team/app");
+ plain.setImageTagMutability("MUTABLE");
+ assertNull(service.updateRepositoryCreationTemplate(plain, REGION).getImageTagMutabilityExclusionFilters());
+ }
+
+ @Test
+ void creationTemplate_describeFiltersAndPagesAndDeleteRemoves() {
+ for (String prefix : List.of("c", "a", "b")) {
+ service.createRepositoryCreationTemplate(template(prefix, "REPLICATION"), REGION);
+ }
+ PaginatedResult<RepositoryCreationTemplate> first =
+ service.describeRepositoryCreationTemplates(null, 2, null, REGION);
+ assertEquals(List.of("a", "b"), first.items().stream().map(RepositoryCreationTemplate::getPrefix).toList());
+ PaginatedResult<RepositoryCreationTemplate> second =
+ service.describeRepositoryCreationTemplates(null, 2, first.nextToken(), REGION);
+ assertEquals(List.of("c"), second.items().stream().map(RepositoryCreationTemplate::getPrefix).toList());
+ assertNull(second.nextToken());
+
+ // A prefix with no template is left out rather than refused.
+ assertEquals(List.of("b"), service.describeRepositoryCreationTemplates(List.of("b", "missing"), null, null, REGION)
+ .items().stream().map(RepositoryCreationTemplate::getPrefix).toList());
+ assertInvalidTemplate(() -> service.describeRepositoryCreationTemplates(null, 1001, null, REGION));
+
+ assertEquals("b", service.deleteRepositoryCreationTemplate("b", REGION).getPrefix());
+ assertEquals("TemplateNotFoundException", assertThrows(AwsException.class,
+ () -> service.deleteRepositoryCreationTemplate("b", REGION)).getErrorCode());
+ assertEquals(2, service.describeRepositoryCreationTemplates(null, null, null, REGION).items().size());
+ }
+
+ @Test
+ void creationTemplate_isKeptPerAccountAndRegion() {
+ InMemoryStorage<String, RepositoryCreationTemplate> shared = new InMemoryStorage<>();
+ EcrService home = new EcrService(new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),
+ new InMemoryStorage<>(), shared, registryManager, Mockito.mock(EmulatorConfig.class),
+ new RegionResolver(REGION, ACCOUNT));
+ EcrService other = new EcrService(new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),
+ new InMemoryStorage<>(), shared, registryManager, Mockito.mock(EmulatorConfig.class),
+ new RegionResolver(REGION, "111111111111"));
+ home.createRepositoryCreationTemplate(template("prod", "REPLICATION"), REGION);
+
+ assertTrue(other.describeRepositoryCreationTemplates(null, null, null, REGION).items().isEmpty());
+ assertTrue(home.describeRepositoryCreationTemplates(null, null, null, "eu-west-1").items().isEmpty());
+ other.createRepositoryCreationTemplate(template("prod", "REPLICATION"), REGION);
+ assertEquals("TemplateNotFoundException", assertThrows(AwsException.class,
+ () -> home.deleteRepositoryCreationTemplate("prod", "eu-west-1")).getErrorCode());
+ }
+
+ /** ECR assumes a {@code /} after every prefix, so a trailing one names the same template. */
+ @Test
+ void creationTemplate_aTrailingSlashNamesTheSameTemplate() {
+ service.createRepositoryCreationTemplate(template("prod/", "REPLICATION"), REGION);
+
+ assertEquals("TemplateAlreadyExistsException", assertThrows(AwsException.class,
+ () -> service.createRepositoryCreationTemplate(template("prod", "REPLICATION"), REGION)).getErrorCode());
+ assertEquals(1, service.describeRepositoryCreationTemplates(List.of("prod"), null, null, REGION)
+ .items().size());
+ PaginatedResult<RepositoryCreationTemplate> both =
+ service.describeRepositoryCreationTemplates(List.of("prod", "prod/"), 1, null, REGION);
+ assertEquals(1, both.items().size());
+ assertNull(both.nextToken());
+ RepositoryCreationTemplate change = template("prod");
+ change.setDescription("changed");
+ assertEquals("changed", service.updateRepositoryCreationTemplate(change, REGION).getDescription());
+ service.deleteRepositoryCreationTemplate("prod", REGION);
+ assertTrue(service.describeRepositoryCreationTemplates(null, null, null, REGION).items().isEmpty());
+ }
+
+ @Test
+ void creationTemplate_aSecondCreateOfThePrefixWaitsAndIsRefused() throws Exception {
+ ParkingStore<RepositoryCreationTemplate> store = new ParkingStore<>();
+ EcrService templates = templateService(store);
+ ExecutorService pool = Executors.newFixedThreadPool(2);
+ try {
+ store.parkNextRead();
+ Future<?> first = pool.submit(() -> templates.createRepositoryCreationTemplate(
+ template("prod", "REPLICATION"), REGION));
+ assertTrue(store.awaitParked());
+ Future<?> second = pool.submit(() -> templates.createRepositoryCreationTemplate(
+ template("prod", "REPLICATION"), REGION));
+ assertThrows(TimeoutException.class, () -> second.get(200, TimeUnit.MILLISECONDS),
+ "the second create must wait for the first");
+
+ store.release();
+ first.get(5, TimeUnit.SECONDS);
+ ExecutionException refused = assertThrows(ExecutionException.class, () -> second.get(5, TimeUnit.SECONDS));
+ assertEquals("TemplateAlreadyExistsException", ((AwsException) refused.getCause()).getErrorCode());
+ } finally {
+ store.release();
+ pool.shutdownNow();
+ }
+ }
+
+ @Test
+ void creationTemplate_aDeleteDuringAnUpdateStaysDeleted() throws Exception {
+ ParkingStore<RepositoryCreationTemplate> store = new ParkingStore<>();
+ EcrService templates = templateService(store);
+ templates.createRepositoryCreationTemplate(template("prod", "REPLICATION"), REGION);
+ RepositoryCreationTemplate change = template("prod");
+ change.setDescription("changed");
+ ExecutorService pool = Executors.newFixedThreadPool(2);
+ try {
+ store.parkNextRead();
+ Future<?> update = pool.submit(() -> templates.updateRepositoryCreationTemplate(change, REGION));
+ assertTrue(store.awaitParked());
+ Future<?> delete = pool.submit(() -> templates.deleteRepositoryCreationTemplate("prod", REGION));
+ assertThrows(TimeoutException.class, () -> delete.get(200, TimeUnit.MILLISECONDS),
+ "the delete must wait for the update");
+
+ store.release();
+ update.get(5, TimeUnit.SECONDS);
+ delete.get(5, TimeUnit.SECONDS);
+ } finally {
+ store.release();
+ pool.shutdownNow();
+ }
+
+ assertTrue(templates.describeRepositoryCreationTemplates(null, null, null, REGION).items().isEmpty());
+ }
+
+ private EcrService templateService(InMemoryStorage<String, RepositoryCreationTemplate> store) {
+ return new EcrService(new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),
+ new InMemoryStorage<>(), store, registryManager, Mockito.mock(EmulatorConfig.class),
+ new RegionResolver(REGION, ACCOUNT));
+ }
}
diff --git a/tools/aws/regen_ecr_shapes.py b/tools/aws/regen_ecr_shapes.py
index 057527e2e2..8ff780bcd7 100644
--- a/tools/aws/regen_ecr_shapes.py
+++ b/tools/aws/regen_ecr_shapes.py
@@ -1,8 +1,8 @@
#!/usr/bin/env python3
"""Vendor ECR request constraints from botocore's Apache-2.0 service model.
-`EcrRequestShapes` checks the registry setting actions against the vendored file through the
-shared `RequestConstraintCheck`: member types, required members, lengths and counts, patterns and
+`EcrRequestShapes` checks the registry setting and repository creation template actions against
+the vendored file through the shared `RequestConstraintCheck`: member types, required members, lengths and counts, patterns and
enum values, as the model states them.
Run from anywhere in the repo:
@@ -26,6 +26,8 @@ OPERATIONS = (
"PutReplicationConfiguration", "DescribeRegistry",
"PutRegistryScanningConfiguration", "GetRegistryScanningConfiguration",
"BatchGetRepositoryScanningConfiguration",
+ "CreateRepositoryCreationTemplate", "UpdateRepositoryCreationTemplate",
+ "DescribeRepositoryCreationTemplates", "DeleteRepositoryCreationTemplate",
)