Light, fluffy, and always free - The AWS Local Emulator alternative
fix(codeartifact): bracket the sidecar container id resolution race in listPackageVersions (#6388)
Priamo Germosencc1ce89ac08f
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.javaindex ef51ca51fc..c94953e9d4 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactService.java@@ -504,6 +504,21 @@ public class CodeArtifactService implements Resettable {return id;}+ /**+ * {@link #ensureFormatContainerId} plus {@link RepositorySidecarManager#beginUse}, both under+ * this same {@code synchronized} monitor {@link #deleteRepository} also holds for its own+ * sidecar cleanup, so a delete can never run its cleanup in the gap between resolving+ * {@code repoId} and registering use of it. Only {@link #listPackageVersions} needs this: it+ * is the one caller of {@link #ensureFormatContainerId} whose sidecar call is bracketed by+ * {@code beginUse}/{@code endUse} at all.+ */+ private synchronized String resolveContainerIdAndBeginUse(String format, String region, String domain,+ String domainOwner, String repository, RepositorySidecarManager manager) {+ String id = ensureFormatContainerId(format, region, domain, domainOwner, repository);+ manager.beginUse(id);+ return id;+ }+public synchronized CodeArtifactRepository updateRepository(String region, String domain, String domainOwner,String repository, String description,List<String> upstreams) {@@ -960,16 +975,22 @@ public class CodeArtifactService implements Resettable {List<PackageVersionEntry> entries;String preferredDisplayVersion = null;if (CONTAINER_BACKED_FORMATS.contains(format)) {- String repoId = ensureFormatContainerId(format, region, domain, owner, repository);RepositorySidecarManager manager = sidecarRegistry.forFormat(format).orElseThrow(() -> notFound("Package '" + packageName + "' was not found.", packageName,"package"));+ // Resolves repoId and registers use of it atomically (see+ // resolveContainerIdAndBeginUse's own javadoc): a repository delete racing in between+ // those two steps must not be able to run a sidecar's own cleanup to completion before+ // this call gets a chance to register itself as using repoId.+ String repoId = resolveContainerIdAndBeginUse(format, region, domain, owner, repository, manager);List<RepositorySidecarManager.PackageVersionTimestamp> raw;try {raw = manager.listPackageVersions(repoId, domain, repository, namespace, packageName);} catch (UnsupportedOperationException e) {throw new AwsException("InternalServerException", "Listing " + format + " package versions is not "+ "yet supported by this emulator.", 500);+ } finally {+ manager.endUse(repoId);}if (raw.isEmpty() && !hasOriginConfig) {throw notFound("Package '" + packageName + "' was not found.", packageName, "package");diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClient.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClient.javaindex dbfabf5231..afa0c6d72e 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClient.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/PypiserverSidecarClient.java@@ -206,6 +206,24 @@ public class PypiserverSidecarClient implements RepositorySidecarManager {}}+ /**+ * Delegates to {@link SidecarConcurrency#beginUse}: {@code CodeArtifactService} calls this+ * right after it resolves {@code repositoryContainerId}, closing the window between that+ * resolution and this client's own {@link #listPackageVersions} call, which brackets the+ * same key again internally. Nesting is safe: {@link SidecarConcurrency}'s bookkeeping is a+ * reference count, not a flag.+ */+ @Override+ public void beginUse(String repositoryContainerId) {+ SidecarConcurrency.beginUse(repositoryContainerId);+ }++ /** Delegates to {@link SidecarConcurrency#endUse}, pairing {@link #beginUse} above. */+ @Override+ public void endUse(String repositoryContainerId) {+ SidecarConcurrency.endUse(repositoryContainerId);+ }+private Instant lastModified(String fileUrl) {HttpRequest request = HttpRequest.newBuilder(URI.create(fileUrl)).timeout(Duration.ofSeconds(10)).method("HEAD", BodyPublishers.noBody()).build();diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/RepositorySidecarManager.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/RepositorySidecarManager.javaindex c834df723e..881260e80a 100644--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/RepositorySidecarManager.java+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/RepositorySidecarManager.java@@ -217,6 +217,25 @@ public interface RepositorySidecarManager {+ "sidecar");}+ /**+ * Marks that {@code repositoryContainerId} is about to be used for {@link+ * #listPackageVersions}, called by {@code CodeArtifactService} right after it resolves that+ * id and before it does anything else with it. Resolving the id and entering {@link+ * #listPackageVersions} are two separate statements there, with a concurrent repository+ * delete's cleanup able to run in between them; pairing this with {@link #endUse} in a+ * {@code try}/{@code finally} around the whole {@link #listPackageVersions} call closes that+ * window the same way {@code PypiserverSidecarClient} already closes the narrower one inside+ * the call itself. Default is a no-op: only a sidecar whose own concurrency bookkeeping dies+ * with the container (pypiserver) has anything here to protect; one with no such bookkeeping,+ * or (Maven) a container that is never torn down, does not.+ */+ default void beginUse(String repositoryContainerId) {+ }++ /** Marks the end of one {@link #beginUse}. Default is a no-op, for the same reason. */+ default void endUse(String repositoryContainerId) {+ }+/*** This format's own preferred "default display" version for a package, independent of publish* recency, for {@code ListPackageVersions}' {@code defaultDisplayVersion}. {@code empty()} bydiff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.javaindex e6ce8a3332..f6f1506599 100644--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactServiceTest.java@@ -28,11 +28,13 @@ import java.util.List;import java.util.Map;import java.util.Optional;import java.util.Set;+import java.util.concurrent.CopyOnWriteArrayList;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 java.util.concurrent.atomic.AtomicReference;import java.util.stream.Collectors;import static org.junit.jupiter.api.Assertions.assertEquals;@@ -43,6 +45,7 @@ import static org.mockito.ArgumentMatchers.any;import static org.mockito.ArgumentMatchers.anyString;import static org.mockito.ArgumentMatchers.eq;import static org.mockito.ArgumentMatchers.isNull;+import static org.mockito.Mockito.doAnswer;import static org.mockito.Mockito.doThrow;import static org.mockito.Mockito.inOrder;import static org.mockito.Mockito.mock;@@ -3413,6 +3416,108 @@ class CodeArtifactServiceTest {}}+ /**+ * {@code ensureFormatContainerId} resolves {@code repoId} and {@code listPackageVersions}+ * itself is called in two separate statements, with a concurrent repository delete's cleanup+ * able to run in between them; {@code beginUse}/{@code endUse} must bracket that gap, not+ * just the sidecar call itself, or a delete racing exactly there would leave a permit cached+ * for a container that is already gone with nothing left to ever clean it up.+ */+ @Test+ void listPackageVersionsBracketsThePypiserverCallWithBeginUseAndEndUse() {+ service.createDomain(REGION, "dom", null, Map.of());+ CodeArtifactRepository created = service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ String repoId = created.getSidecarContainerIds().get("pypi");+ when(pypiserverClient.listPackageVersions(eq(repoId), eq("dom"), eq("repo"), isNull(), eq("my-pkg")))+ .thenReturn(List.of(new RepositorySidecarManager.PackageVersionTimestamp("1.0.0", null)));++ service.listPackageVersions(REGION, "dom", null, "repo", "pypi", null, "my-pkg", null, null, null, null,+ null);++ InOrder order = inOrder(pypiserverClient);+ order.verify(pypiserverClient).beginUse(repoId);+ order.verify(pypiserverClient).listPackageVersions(repoId, "dom", "repo", null, "my-pkg");+ order.verify(pypiserverClient).endUse(repoId);+ }++ @Test+ void listPackageVersionsCallsEndUseEvenWhenTheSidecarCallFails() {+ service.createDomain(REGION, "dom", null, Map.of());+ CodeArtifactRepository created = service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());+ String repoId = created.getSidecarContainerIds().get("pypi");+ doThrow(new IllegalStateException("sidecar unreachable")).when(pypiserverClient)+ .listPackageVersions(eq(repoId), eq("dom"), eq("repo"), isNull(), eq("my-pkg"));++ assertThrows(IllegalStateException.class, () -> service.listPackageVersions(REGION, "dom", null, "repo",+ "pypi", null, "my-pkg", null, null, null, null, null));++ verify(pypiserverClient).endUse(repoId);+ }++ /**+ * {@code listPackageVersions} and {@code deleteRepository} can never interleave: resolving+ * {@code repoId} and calling {@code beginUse} happen under the same lock {@code+ * deleteRepository} holds for its own sidecar cleanup. Parks {@code beginUse} while it still+ * holds that lock, confirms a concurrently-started delete cannot even begin until it is+ * released, then confirms the delete's {@code release} call never runs until {@code beginUse}+ * has returned.+ */+ @Test+ void listPackageVersionsNeverRegistersUseWhileADeleteIsStillCleaningUpTheSameRepository()+ throws InterruptedException {+ service.createDomain(REGION, "dom", null, Map.of());+ service.createRepository(REGION, "dom", null, "repo", null, null, Map.of());++ List<String> events = new CopyOnWriteArrayList<>();+ CountDownLatch beginUseStarted = new CountDownLatch(1);+ CountDownLatch beginUseMayFinish = new CountDownLatch(1);+ doAnswer(invocation -> {+ events.add("beginUse-start");+ beginUseStarted.countDown();+ beginUseMayFinish.await(5, TimeUnit.SECONDS);+ events.add("beginUse-end");+ return null;+ }).when(pypiserverClient).beginUse(anyString());+ doAnswer(invocation -> {+ events.add("release");+ return null;+ }).when(pypiserverClient).release(anyString());++ AtomicReference<Throwable> listingFailure = new AtomicReference<>();+ Thread lister = new Thread(() -> {+ try {+ service.listPackageVersions(REGION, "dom", null, "repo", "pypi", null, "my-pkg", null, null, null,+ null, null);+ } catch (Throwable t) {+ listingFailure.set(t);+ }+ });+ lister.start();+ assertTrue(beginUseStarted.await(5, TimeUnit.SECONDS), "expected listPackageVersions to reach beginUse "+ + "while still holding the service's lock");++ Thread deleter = new Thread(() -> service.deleteRepository(REGION, "dom", null, "repo"));+ deleter.start();+ deleter.join(200);+ assertTrue(deleter.isAlive(), "expected deleteRepository to block trying to acquire the service's lock "+ + "while listPackageVersions still holds it inside beginUse");+ assertFalse(events.contains("release"), "expected deleteRepository to not have reached its sidecar "+ + "release call while listPackageVersions still holds the lock");++ beginUseMayFinish.countDown();+ lister.join(5_000);+ deleter.join(5_000);++ assertTrue(listingFailure.get() == null || listingFailure.get() instanceof AwsException,+ "expected listPackageVersions to either succeed or fail with a real error, got "+ + listingFailure.get());+ int beginUseEndIndex = events.indexOf("beginUse-end");+ int releaseIndex = events.indexOf("release");+ assertTrue(beginUseEndIndex != -1 && releaseIndex != -1 && releaseIndex > beginUseEndIndex,+ "expected the delete's release call to only ever run after beginUse had fully finished; recorded "+ + "order was " + events);+ }+@Testvoid listPackageVersionsFailsNotFoundForAContainerBackedPackageThatWasNeverPublished() {service.createDomain(REGION, "dom", null, Map.of());