Skip to content

armgit / floci

Public Imported from GitHub
0

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.java
index 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.java
index 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.java
index 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()} by
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.java
index 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);
+ }
+
@Test
void listPackageVersionsFailsNotFoundForAContainerBackedPackageThatWasNeverPublished() {
service.createDomain(REGION, "dom", null, Map.of());