Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

fix(sdk-java): dispatch nothing for an already interrupted caller

Yudhi Armyndharis971c1716af29
diff --git a/sdk/java/src/main/java/com/rmyndharis/openwa/http/DefaultHttpTransport.java b/sdk/java/src/main/java/com/rmyndharis/openwa/http/DefaultHttpTransport.java
index 81711f4b5..2763293dc 100644
--- a/sdk/java/src/main/java/com/rmyndharis/openwa/http/DefaultHttpTransport.java
+++ b/sdk/java/src/main/java/com/rmyndharis/openwa/http/DefaultHttpTransport.java
@@ -14,12 +14,24 @@ import java.util.concurrent.TimeoutException;
/** Default transport backed by {@link java.net.http.HttpClient}. Never follows redirects. */
public final class DefaultHttpTransport implements HttpTransport {
- private final HttpClient client = HttpClient.newBuilder()
- .followRedirects(HttpClient.Redirect.NEVER)
- .build();
+ private final HttpClient client;
+
+ public DefaultHttpTransport() {
+ this(HttpClient.newBuilder().followRedirects(HttpClient.Redirect.NEVER).build());
+ }
+
+ /** Lets a test observe whether an exchange was started. */
+ DefaultHttpTransport(HttpClient client) {
+ this.client = client;
+ }
@Override
public HttpResponseData send(HttpRequestData req) throws IOException, InterruptedException {
+ // As HttpClient.send does: a thread whose interrupt flag is already set dispatches nothing, so
+ // the caller is never told the call was interrupted after its request went out.
+ if (Thread.interrupted()) {
+ throw new InterruptedException();
+ }
HttpRequest.BodyPublisher pub = req.body() == null
? HttpRequest.BodyPublishers.noBody()
: HttpRequest.BodyPublishers.ofString(req.body());
diff --git a/sdk/java/src/test/java/com/rmyndharis/openwa/http/DefaultHttpTransportTest.java b/sdk/java/src/test/java/com/rmyndharis/openwa/http/DefaultHttpTransportTest.java
index 04bab7614..c1c74d306 100644
--- a/sdk/java/src/test/java/com/rmyndharis/openwa/http/DefaultHttpTransportTest.java
+++ b/sdk/java/src/test/java/com/rmyndharis/openwa/http/DefaultHttpTransportTest.java
@@ -12,17 +12,32 @@ import com.rmyndharis.openwa.errors.OpenWAApiError;
import com.rmyndharis.openwa.errors.OpenWATimeoutError;
import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
+import java.net.Authenticator;
+import java.net.CookieHandler;
import java.net.InetSocketAddress;
+import java.net.ProxySelector;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.DateTimeException;
import java.time.Duration;
+import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLParameters;
import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
/** Runs the real transport against a local server: no client test covers it otherwise. */
class DefaultHttpTransportTest {
@@ -89,12 +104,15 @@ class DefaultHttpTransportTest {
}
@Test
+ @Timeout(30)
void mapsABodyStallToOpenWATimeoutErrorAndDropsTheConnection() throws Exception {
+ CountDownLatch started = new CountDownLatch(1);
CountDownLatch clientClosed = new CountDownLatch(1);
server.createContext("/stall", ex -> {
try {
// A body that never ends: keeps writing until the client hangs up.
ex.sendResponseHeaders(200, 0);
+ started.countDown();
while (!release.await(20, TimeUnit.MILLISECONDS)) {
ex.getResponseBody().write(' ');
ex.getResponseBody().flush();
@@ -108,13 +126,19 @@ class DefaultHttpTransportTest {
}
});
+ // The budget covers connecting and a fresh client's first use as well, so a starved machine
+ // needs more than the 100 ms of the header-timeout test; the server stalls for as long as it takes.
assertThrows(OpenWATimeoutError.class,
- () -> client(Duration.ofMillis(100)).requestVoid(HttpMethod.GET, "/stall", null, null));
+ () -> client(Duration.ofMillis(1500)).requestVoid(HttpMethod.GET, "/stall", null, null));
+ assertTrue(started.await(5, TimeUnit.SECONDS), "the stalled exchange never reached the server");
assertTrue(clientClosed.await(5, TimeUnit.SECONDS), "the timed-out exchange was not cancelled");
}
@Test
void reportsAFailedExchangeAsAnIOException() {
+ // The failure is HttpClient's own: older JDKs overflow computing a FOREVER deadline, newer ones
+ // saturate and send the request. transportFailure is covered on its own below either way.
+ Assumptions.assumeTrue(overflowsOnThisJdk(), "this JDK schedules a FOREVER timeout without overflowing");
AtomicInteger hits = new AtomicInteger();
server.createContext("/ok", ex -> {
hits.incrementAndGet();
@@ -131,6 +155,64 @@ class DefaultHttpTransportTest {
assertEquals(0, hits.get());
}
+ private static boolean overflowsOnThisJdk() {
+ try {
+ Instant.now().plus(ChronoUnit.FOREVER.getDuration());
+ return false;
+ } catch (ArithmeticException | DateTimeException e) {
+ return true;
+ }
+ }
+
+ /** A client that only records whether an exchange was started. */
+ private static final class RecordingClient extends HttpClient {
+ final AtomicInteger started = new AtomicInteger();
+
+ @Override public Optional<CookieHandler> cookieHandler() { return Optional.empty(); }
+ @Override public Optional<Duration> connectTimeout() { return Optional.empty(); }
+ @Override public Redirect followRedirects() { return Redirect.NEVER; }
+ @Override public Optional<ProxySelector> proxy() { return Optional.empty(); }
+ @Override public SSLContext sslContext() { throw new UnsupportedOperationException(); }
+ @Override public SSLParameters sslParameters() { throw new UnsupportedOperationException(); }
+ @Override public Optional<Authenticator> authenticator() { return Optional.empty(); }
+ @Override public Version version() { return Version.HTTP_1_1; }
+ @Override public Optional<Executor> executor() { return Optional.empty(); }
+
+ @Override
+ public <T> HttpResponse<T> send(HttpRequest request, HttpResponse.BodyHandler<T> handler) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public <T> CompletableFuture<HttpResponse<T>> sendAsync(
+ HttpRequest request, HttpResponse.BodyHandler<T> handler) {
+ started.incrementAndGet();
+ return new CompletableFuture<>();
+ }
+
+ @Override
+ public <T> CompletableFuture<HttpResponse<T>> sendAsync(
+ HttpRequest request, HttpResponse.BodyHandler<T> handler, HttpResponse.PushPromiseHandler<T> push) {
+ return sendAsync(request, handler);
+ }
+ }
+
+ @Test
+ void aCallerThatIsAlreadyInterruptedStartsNoExchange() {
+ // HttpClient.send refuses before dispatching anything when the thread's interrupt flag is set;
+ // starting the exchange first could still deliver a request the caller is told was interrupted.
+ RecordingClient recording = new RecordingClient();
+ HttpRequestData req = new HttpRequestData(
+ HttpMethod.GET, baseUrl + "/ok", Map.of(), null, Duration.ofSeconds(5));
+ Thread.currentThread().interrupt();
+ try {
+ assertThrows(InterruptedException.class, () -> new DefaultHttpTransport(recording).send(req));
+ } finally {
+ Thread.interrupted();
+ }
+ assertEquals(0, recording.started.get());
+ }
+
@Test
void passesThroughOnlyTheFailuresHttpClientSendDoes() {
IOException io = new IOException("reset");