Skip to content

armgit / floci

Public Imported from GitHub
0

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

perf(codeartifact): parallelize per-version metadata fetches in ListPackageVersions (#6262)

Priamo Germosen581cd6279013
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 a0dcc7cdd3..dc6b2ae8ff 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
@@ -149,6 +149,12 @@ public class PypiserverSidecarClient implements RepositorySidecarManager {
* lands on disk within the same upload, close enough that picking "the first one" over "the
* most recently modified one" makes no practical difference, and the JSON listing gives no
* way to know which upload order they actually arrived in regardless.
+ *
+ * <p>The per-version {@code HEAD} requests run through {@link SidecarConcurrency#mapBounded},
+ * not a plain sequential loop: a package with many versions used to make every one of those
+ * requests one at a time before returning even a single-result page. Keyed by {@code
+ * repositoryContainerId} so the concurrency cap holds across simultaneous calls against the
+ * same pypiserver container, not just within one of them.
*/
@Override
public List<PackageVersionTimestamp> listPackageVersions(String repositoryContainerId, String domain,
@@ -178,13 +184,13 @@ public class PypiserverSidecarClient implements RepositorySidecarManager {
} catch (Exception e) {
throw new IllegalStateException("Could not parse pypiserver's version listing for " + packageName, e);
}
- List<PackageVersionTimestamp> result = new ArrayList<>();
- releases.fieldNames().forEachRemaining(version -> {
+ List<String> versions = new ArrayList<>();
+ releases.fieldNames().forEachRemaining(versions::add);
+ return SidecarConcurrency.mapBounded(repositoryContainerId, versions, version -> {
JsonNode files = releases.path(version);
String fileUrl = files.isEmpty() ? "" : files.get(0).path("url").asText("");
- result.add(new PackageVersionTimestamp(version, fileUrl.isEmpty() ? null : lastModified(fileUrl)));
+ return new PackageVersionTimestamp(version, fileUrl.isEmpty() ? null : lastModified(fileUrl));
});
- return result;
}
private Instant lastModified(String fileUrl) {
diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.java
index 5f455c821f..b7463f097c 100644
--- a/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.java
+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/ReposiliteSidecarClient.java
@@ -42,6 +42,13 @@ public class ReposiliteSidecarClient implements RepositorySidecarManager {
private static final String FORMAT = "maven";
private static final Logger LOG = Logger.getLogger(ReposiliteSidecarClient.class);
private static final String MAVEN_SETTINGS_PATH = "/api/settings/domain/maven";
+ /**
+ * {@link SidecarConcurrency#mapBounded}'s key for every {@code listPackageVersions} call: one
+ * shared constant, since {@link ReposiliteSidecarManager} backs every CodeArtifact Maven
+ * repository with the same single container, unlike pypiserver's one-container-per-repository
+ * shape.
+ */
+ private static final String SHARED_CONTAINER_KEY = "reposilite";
private static final int REPOSITORY_READY_POLL_MAX_MS = 3_000;
private static final int REPOSITORY_READY_POLL_INTERVAL_MS = 50;
/** Real Maven metadata's own documented {@code lastUpdated} shape: UTC, {@code yyyyMMddHHmmss}. */
@@ -274,6 +281,12 @@ public class ReposiliteSidecarClient implements RepositorySidecarManager {
* "when this version became complete." A version directory with no {@code FILE} entries at
* all (never happens through a real deploy, but not assumed impossible) reports no timestamp
* rather than guessing one.
+ *
+ * <p>The per-version details requests run through {@link SidecarConcurrency#mapBounded}, not a
+ * plain sequential loop: an artifact with many versions used to make every one of those
+ * requests one at a time before returning even a single-result page. Keyed by {@link
+ * #SHARED_CONTAINER_KEY} so the concurrency cap holds across simultaneous calls too, since
+ * every Maven repository shares the one Reposilite container.
*/
@Override
public List<PackageVersionTimestamp> listPackageVersions(String repositoryContainerId, String domain,
@@ -295,16 +308,15 @@ public class ReposiliteSidecarClient implements RepositorySidecarManager {
throw new IllegalStateException("Could not list versions of " + packageName + " on the Reposilite "
+ "sidecar: upstream returned " + artifactResponse.statusCode());
}
- List<PackageVersionTimestamp> result = new ArrayList<>();
+ List<String> versions = new ArrayList<>();
for (JsonNode entry : readTree(artifactResponse.body()).path("files")) {
- if (!"DIRECTORY".equals(entry.path("type").asText())) {
- continue;
+ if ("DIRECTORY".equals(entry.path("type").asText())) {
+ versions.add(entry.path("name").asText());
}
- String version = entry.path("name").asText();
- result.add(new PackageVersionTimestamp(version, latestFileTimestamp(baseUrl,
- versionDetailsPath(repositoryContainerId, namespace, packageName, version))));
}
- return result;
+ return SidecarConcurrency.mapBounded(SHARED_CONTAINER_KEY, versions, version -> new PackageVersionTimestamp(
+ version, latestFileTimestamp(baseUrl, versionDetailsPath(repositoryContainerId, namespace,
+ packageName, version))));
}
private Instant latestFileTimestamp(String baseUrl, String versionDetailsPath) {
diff --git a/src/main/java/io/github/hectorvent/floci/services/codeartifact/SidecarConcurrency.java b/src/main/java/io/github/hectorvent/floci/services/codeartifact/SidecarConcurrency.java
new file mode 100644
index 0000000000..70358fe482
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/codeartifact/SidecarConcurrency.java
@@ -0,0 +1,131 @@
+package io.github.hectorvent.floci.services.codeartifact;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.Semaphore;
+import java.util.function.Function;
+
+/**
+ * Bounds the fan-out {@code listPackageVersions} needs when a sidecar has no single call that
+ * returns every version's publish time at once: pypiserver answers with no timestamp field at
+ * all (one {@code HEAD} per version), and Reposilite's per-version details page is the only way
+ * to read a version's own file timestamps (one {@code GET} per version). Running those
+ * sequentially means a one-result page still waits on every version in the package; running them
+ * all at once risks opening as many sockets against the sidecar container as the package has
+ * versions. Package-private: both callers live in this package, and the ordering/exception
+ * guarantees below are shaped around what {@code listPackageVersions} specifically needs, not a
+ * general-purpose utility.
+ */
+final class SidecarConcurrency {
+
+ /**
+ * How many per-item requests run against one sidecar container at once, no matter how many
+ * {@code listPackageVersions} calls against that same container are in flight at the same
+ * time: large enough that a package with a realistic number of versions sees a real speedup,
+ * small enough that the container backing a sidecar can't be flooded with hundreds of
+ * simultaneous connections.
+ */
+ private static final int MAX_CONCURRENT_REQUESTS = 8;
+
+ /**
+ * One {@link Semaphore} per sidecar container, shared across every {@code mapBounded} call for
+ * that container so {@link #MAX_CONCURRENT_REQUESTS} holds in aggregate: a per-call-only limit
+ * would let two simultaneous {@code listPackageVersions} calls against the same container each
+ * open that many connections, doubling the real cap. The key is whatever identity a caller
+ * already has for "which container": pypiserver's own {@code repositoryContainerId} (one
+ * container per CodeArtifact repository), or a single shared constant for Reposilite (one
+ * container for every Maven repository).
+ */
+ private static final Map<Object, Semaphore> SIDECAR_PERMITS = new ConcurrentHashMap<>();
+
+ /**
+ * Virtual threads, not a platform-thread pool: {@code mapBounded} submits every item up front and
+ * lets the semaphore above do the actual gating, so a package with thousands of versions would
+ * otherwise start as many platform threads per call, each parked in {@link Semaphore#acquire()}.
+ * Same approach {@link io.github.hectorvent.floci.services.codepipeline.CodePipelineService} already
+ * uses for its own I/O-bound fan-out.
+ */
+ private static final ExecutorService EXECUTOR = Executors.newVirtualThreadPerTaskExecutor();
+
+ private SidecarConcurrency() {
+ }
+
+ /**
+ * Applies {@code perItem} to every element of {@code items}, in parallel up to {@link
+ * #MAX_CONCURRENT_REQUESTS} at a time against {@code sidecarKey}'s container, and returns the
+ * results in the same order as {@code items}. A single item's failure fails the whole call,
+ * exactly as the original sequential loops this replaces did: the first failure's own
+ * exception propagates (unwrapped from the {@link ExecutionException} every {@link Future}
+ * wraps it in), the same error the caller would have seen from a plain sequential loop that
+ * stopped on that item.
+ *
+ * <p>Every other item is then cancelled too: one still queued never starts at all, and one
+ * already running is interrupted. Without this, a failure (or the caller thread being
+ * interrupted) would leave the rest of the package's requests running against the sidecar in
+ * the background even after the call itself has already failed.
+ *
+ * <p>Zero or one item skips the executor and the permit entirely and calls {@code perItem}
+ * directly on the calling thread, since there is nothing to parallelize and nothing worth
+ * bounding for it.
+ */
+ static <T, R> List<R> mapBounded(Object sidecarKey, List<T> items, Function<T, R> perItem) {
+ if (items.size() <= 1) {
+ List<R> result = new ArrayList<>(items.size());
+ for (T item : items) {
+ result.add(perItem.apply(item));
+ }
+ return result;
+ }
+ Semaphore permits = SIDECAR_PERMITS.computeIfAbsent(sidecarKey, key -> new Semaphore(MAX_CONCURRENT_REQUESTS));
+ List<Future<R>> futures = new ArrayList<>(items.size());
+ for (T item : items) {
+ futures.add(EXECUTOR.submit(() -> runWithPermit(permits, perItem, item)));
+ }
+ boolean succeeded = false;
+ try {
+ List<R> results = new ArrayList<>(items.size());
+ for (Future<R> future : futures) {
+ results.add(await(future));
+ }
+ succeeded = true;
+ return results;
+ } finally {
+ if (!succeeded) {
+ for (Future<R> future : futures) {
+ future.cancel(true);
+ }
+ }
+ }
+ }
+
+ private static <T, R> R runWithPermit(Semaphore permits, Function<T, R> perItem, T item)
+ throws InterruptedException {
+ permits.acquire();
+ try {
+ return perItem.apply(item);
+ } finally {
+ permits.release();
+ }
+ }
+
+ private static <R> R await(Future<R> future) {
+ try {
+ return future.get();
+ } catch (ExecutionException e) {
+ Throwable cause = e.getCause();
+ if (cause instanceof RuntimeException runtimeException) {
+ throw runtimeException;
+ }
+ throw new IllegalStateException(cause);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ throw new IllegalStateException("Interrupted while waiting on a sidecar request", e);
+ }
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactMavenDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactMavenDockerIntegrationTest.java
index 91660fb075..3c5dc41d6a 100644
--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactMavenDockerIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactMavenDockerIntegrationTest.java
@@ -20,7 +20,10 @@ import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
+import java.util.HashSet;
+import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@@ -590,6 +593,45 @@ class CodeArtifactMavenDockerIntegrationTest {
.body("versions[0].origin.originType", equalTo("INTERNAL"));
}
+ /**
+ * The real-world gap this guards against: {@code ReposiliteSidecarClient#listPackageVersions}
+ * used to fetch every version's publish-time details page one at a time, so a package with
+ * many versions still answered no faster than its slowest version's own round trip, times the
+ * version count. This deploys enough versions that a broken fan-out (dropped, duplicated, or
+ * silently empty results from the bounded executor) would show up as something other than
+ * exactly this set of versions, against the real Reposilite sidecar, not a mock.
+ */
+ @Test
+ @Order(22)
+ void listPackageVersionsFetchesManyVersionsPublishTimesCorrectly() {
+ String packageName = "manyversions";
+ int versionCount = 12;
+ Set<String> expectedVersions = new HashSet<>();
+ for (int i = 1; i <= versionCount; i++) {
+ String version = "1.0." + i;
+ expectedVersions.add(version);
+ byte[] content = ("many-versions-bytes-" + i).getBytes(StandardCharsets.UTF_8);
+ given().header("Authorization", "Bearer " + bearerToken).body(content)
+ .put("/codeartifact/maven/" + DOMAIN + "/" + REPO + "/com/example/" + packageName + "/" + version
+ + "/" + packageName + "-" + version + ".jar")
+ .then().statusCode(200);
+ }
+
+ JsonPath body = given().header("Authorization", AUTH)
+ .post("/v1/package/versions?domain=" + DOMAIN + "&repository=" + REPO + "&format=maven"
+ + "&namespace=com.example&package=" + packageName)
+ .then().statusCode(200)
+ .body("package", equalTo(packageName))
+ .body("versions.size()", equalTo(versionCount))
+ .extract().jsonPath();
+ List<String> actualVersions = body.getList("versions.version", String.class);
+ assertEquals(expectedVersions, new HashSet<>(actualVersions));
+ String defaultDisplayVersion = body.getString("defaultDisplayVersion");
+ assertTrue(expectedVersions.contains(defaultDisplayVersion),
+ "expected defaultDisplayVersion to be one of the deployed versions, got "
+ + defaultDisplayVersion);
+ }
+
/**
* A throwaway groupId/artifactId, not {@link #GAV}: deleting it exercises Reposilite's real
* directory delete (confirmed live before this was built: a single {@code DELETE} on the
diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactPypiDockerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactPypiDockerIntegrationTest.java
index f8f6ec83a7..6619550b0f 100644
--- a/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactPypiDockerIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/CodeArtifactPypiDockerIntegrationTest.java
@@ -18,8 +18,10 @@ import org.junit.jupiter.api.TestMethodOrder;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@@ -728,6 +730,47 @@ class CodeArtifactPypiDockerIntegrationTest {
throw new AssertionError("expected an asset named " + name + " among " + assets);
}
+ /**
+ * The real-world gap this guards against: {@code PypiserverSidecarClient#listPackageVersions}
+ * used to send one {@code HEAD} per version, one at a time, so a package with many versions
+ * answered no faster than its slowest version's own round trip, times the version count. This
+ * uploads enough versions that a broken fan-out (dropped, duplicated, or silently empty results
+ * from the bounded executor) would show up as something other than exactly this set of
+ * versions, against the real pypiserver sidecar, not a mock.
+ */
+ @Test
+ @Order(21)
+ void listPackageVersionsFetchesManyVersionsPublishTimesCorrectly() {
+ String packageName = "many-versions-pypi-pkg";
+ int versionCount = 12;
+ Set<String> expectedVersions = new HashSet<>();
+ for (int i = 1; i <= versionCount; i++) {
+ String version = "1.0." + i;
+ expectedVersions.add(version);
+ String filename = "many_versions_pypi_pkg-" + version + ".tar.gz";
+ byte[] content = ("many-versions-sdist-bytes-" + i).getBytes(StandardCharsets.UTF_8);
+ given().header("Authorization", "Bearer " + bearerToken)
+ .contentType("multipart/form-data; boundary=boundary123")
+ .body(twineUploadBody("boundary123", packageName, filename, content))
+ .post("/codeartifact/pypi/" + DOMAIN + "/" + REPO + "/")
+ .then().statusCode(200);
+ }
+
+ JsonPath body = given().header("Authorization", AUTH)
+ .post("/v1/package/versions?domain=" + DOMAIN + "&repository=" + REPO + "&format=pypi"
+ + "&package=" + packageName)
+ .then().statusCode(200)
+ .body("package", equalTo(packageName))
+ .body("versions.size()", equalTo(versionCount))
+ .extract().jsonPath();
+ List<String> actualVersions = body.getList("versions.version", String.class);
+ assertEquals(expectedVersions, new HashSet<>(actualVersions));
+ String defaultDisplayVersion = body.getString("defaultDisplayVersion");
+ assertTrue(expectedVersions.contains(defaultDisplayVersion),
+ "expected defaultDisplayVersion to be one of the uploaded versions, got "
+ + defaultDisplayVersion);
+ }
+
/**
* Proves the actual mechanism, not just that {@code PypiserverSidecarManager} has a method
* named right: {@code ContainerTeardowns.stopAll} runs every {@code ContainerTeardown} on
diff --git a/src/test/java/io/github/hectorvent/floci/services/codeartifact/SidecarConcurrencyTest.java b/src/test/java/io/github/hectorvent/floci/services/codeartifact/SidecarConcurrencyTest.java
new file mode 100644
index 0000000000..7eb0fe1079
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/codeartifact/SidecarConcurrencyTest.java
@@ -0,0 +1,177 @@
+package io.github.hectorvent.floci.services.codeartifact;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * Focused unit coverage for the bounded-fan-out helper {@code PypiserverSidecarClient} and {@code
+ * ReposiliteSidecarClient} both use to parallelize their per-version {@code listPackageVersions}
+ * requests. These tests use plain in-process work, not real HTTP, to pin down the properties that
+ * matter: results come back in input order regardless of completion order, more than {@code
+ * MAX_CONCURRENT_REQUESTS} items never run at once against one sidecar key (even across two
+ * simultaneous calls sharing that key), a failing item fails the whole call with its own real
+ * exception rather than a wrapped or swallowed one, and the rest of the work is cancelled rather
+ * than left running after a failure.
+ */
+class SidecarConcurrencyTest {
+
+ @Test
+ void mapBoundedPreservesInputOrderRegardlessOfCompletionOrder() {
+ List<Integer> items = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ List<String> result = SidecarConcurrency.mapBounded(new Object(), items, i -> {
+ // Later items sleep less, so they would finish first if order depended on completion.
+ try {
+ Thread.sleep((11 - i) % 4);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ fail("interrupted");
+ }
+ return "v" + i;
+ });
+ assertThat(result, equalTo(List.of("v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8", "v9", "v10")));
+ }
+
+ @Test
+ void mapBoundedNeverRunsMoreThanTheConcurrencyCapAtOnce() throws InterruptedException {
+ int itemCount = 32;
+ List<Integer> items = new ArrayList<>(itemCount);
+ for (int i = 0; i < itemCount; i++) {
+ items.add(i);
+ }
+ AtomicInteger concurrent = new AtomicInteger();
+ AtomicInteger maxObserved = new AtomicInteger();
+ CountDownLatch allDone = new CountDownLatch(1);
+ Thread worker = new Thread(() -> {
+ SidecarConcurrency.mapBounded(new Object(), items, i -> {
+ int current = concurrent.incrementAndGet();
+ maxObserved.getAndUpdate(previous -> Math.max(previous, current));
+ try {
+ Thread.sleep(20);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ }
+ concurrent.decrementAndGet();
+ return i;
+ });
+ allDone.countDown();
+ });
+ worker.start();
+ assertTrue(allDone.await(10, TimeUnit.SECONDS), "mapBounded did not finish in time");
+ assertTrue(maxObserved.get() <= 8, "expected at most 8 concurrent items, saw " + maxObserved.get());
+ assertTrue(maxObserved.get() > 1, "expected real parallelism, saw " + maxObserved.get());
+ }
+
+ @Test
+ void mapBoundedCapsConcurrencyAcrossSimultaneousCallsSharingTheSameSidecarKey() throws InterruptedException {
+ Object sharedKey = new Object();
+ int itemsPerCall = 6;
+ List<Integer> items = new ArrayList<>(itemsPerCall);
+ for (int i = 0; i < itemsPerCall; i++) {
+ items.add(i);
+ }
+ AtomicInteger concurrent = new AtomicInteger();
+ AtomicInteger maxObserved = new AtomicInteger();
+ Runnable call = () -> SidecarConcurrency.mapBounded(sharedKey, items, i -> {
+ int current = concurrent.incrementAndGet();
+ maxObserved.getAndUpdate(previous -> Math.max(previous, current));
+ try {
+ Thread.sleep(50);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ }
+ concurrent.decrementAndGet();
+ return i;
+ });
+ Thread callA = new Thread(call);
+ Thread callB = new Thread(call);
+ callA.start();
+ callB.start();
+ callA.join(10_000);
+ callB.join(10_000);
+ assertThat("two simultaneous calls sharing one sidecar key must not exceed the shared cap in aggregate",
+ maxObserved.get(), lessThanOrEqualTo(8));
+ assertThat("expected the two calls' work to actually overlap under the shared cap", maxObserved.get(),
+ greaterThan(itemsPerCall));
+ }
+
+ @Test
+ void mapBoundedPropagatesARuntimeExceptionFromAFailingItemUnwrapped() {
+ List<Integer> items = List.of(1, 2, 3);
+ IllegalStateException thrown = assertThrows(IllegalStateException.class, () -> SidecarConcurrency.mapBounded(
+ new Object(), items, i -> {
+ if (i == 2) {
+ throw new IllegalStateException("boom on " + i);
+ }
+ return i;
+ }));
+ assertThat(thrown.getMessage(), equalTo("boom on 2"));
+ }
+
+ @Test
+ void mapBoundedCancelsTheOtherItemAfterAnEarlyFailure() throws InterruptedException {
+ CountDownLatch otherItemStarted = new CountDownLatch(1);
+ CountDownLatch otherItemFinished = new CountDownLatch(1);
+ CountDownLatch neverOpens = new CountDownLatch(1);
+ AtomicBoolean otherItemInterrupted = new AtomicBoolean(false);
+ assertThrows(IllegalStateException.class, () -> SidecarConcurrency.mapBounded(new Object(), List.of(1, 2),
+ i -> {
+ if (i == 1) {
+ // Only fail once item 2 is actually running and blocked, so this exercises real
+ // cancellation of in-flight work instead of racing against whether item 2's task
+ // had even been scheduled yet.
+ boolean started;
+ try {
+ started = otherItemStarted.await(5, TimeUnit.SECONDS);
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ started = false;
+ }
+ if (!started) {
+ throw new IllegalStateException("item 2 never started");
+ }
+ throw new IllegalStateException("boom");
+ }
+ otherItemStarted.countDown();
+ try {
+ neverOpens.await();
+ } catch (InterruptedException e) {
+ otherItemInterrupted.set(true);
+ Thread.currentThread().interrupt();
+ } finally {
+ otherItemFinished.countDown();
+ }
+ return i;
+ }));
+ assertTrue(otherItemFinished.await(5, TimeUnit.SECONDS), "expected mapBounded to cancel item 2 once item "
+ + "1 had already failed, instead of leaving it blocked indefinitely");
+ assertTrue(otherItemInterrupted.get(), "expected item 2 to be interrupted rather than complete normally "
+ + "after item 1 had already failed");
+ }
+
+ @Test
+ void mapBoundedCallsPerItemDirectlyWhenThereIsAtMostOneItem() {
+ Set<String> threadNames = ConcurrentHashMap.newKeySet();
+ List<Integer> result = SidecarConcurrency.mapBounded(new Object(), List.of(42), i -> {
+ threadNames.add(Thread.currentThread().getName());
+ return i;
+ });
+ assertThat(result, equalTo(List.of(42)));
+ assertThat(threadNames, equalTo(Set.of(Thread.currentThread().getName())));
+ }
+}