From 5584bb6a790a6078a7868d8357dc473cd55f9ef7 Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Fri, 21 Nov 2025 16:52:34 +0000 Subject: [PATCH 1/6] Migrate jetty-client to vertx-web-client Replaced jetty-client dependency with vertx-web-client. Refactored `IHttpClient` and its implementation `HttpClientWrapper` to use Vert.x WebClient. Updated `HttpClientModule` to configure and provide `VertxHttpClient`. Removed `JettyHttpClient` and updated imports. Maintained compatibility with synchronous execution using `CompletableFuture`. Restored max response size check in `HttpClientWrapper`. Addressed review feedback regarding idle timeout configuration. --- pom.xml | 6 +- .../eddi/engine/httpclient/IHttpClient.java | 4 - .../bootstrap/HttpClientModule.java | 75 +++--- .../httpclient/impl/HttpClientWrapper.java | 219 +++++++++++------- ...tyHttpClient.java => VertxHttpClient.java} | 8 +- 5 files changed, 174 insertions(+), 138 deletions(-) rename src/main/java/ai/labs/eddi/engine/httpclient/impl/{JettyHttpClient.java => VertxHttpClient.java} (57%) diff --git a/pom.xml b/pom.xml index d084a75d4..f5a780995 100644 --- a/pom.xml +++ b/pom.xml @@ -267,9 +267,9 @@ 3.3.4 - org.eclipse.jetty - jetty-client - ${jetty.version} + io.vertx + vertx-web-client + 5.0.5 jakarta.transaction diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/IHttpClient.java b/src/main/java/ai/labs/eddi/engine/httpclient/IHttpClient.java index f95eb773e..f3adfca2d 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/IHttpClient.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/IHttpClient.java @@ -1,7 +1,5 @@ package ai.labs.eddi.engine.httpclient; -import org.eclipse.jetty.http.HttpCookieStore; - import java.net.URI; public interface IHttpClient { @@ -14,8 +12,6 @@ enum Method { PATCH } - HttpCookieStore getCookieStore(); - IRequest newRequest(URI uri); IRequest newRequest(URI uri, Method method); diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java b/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java index 3aedd70bf..523f2e8b6 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java @@ -1,25 +1,23 @@ package ai.labs.eddi.engine.httpclient.bootstrap; -import ai.labs.eddi.engine.httpclient.impl.JettyHttpClient; +import ai.labs.eddi.engine.httpclient.impl.VertxHttpClient; +import io.vertx.core.Vertx; +import io.vertx.ext.web.client.WebClient; +import io.vertx.ext.web.client.WebClientOptions; import jakarta.enterprise.context.ApplicationScoped; import jakarta.inject.Inject; import jakarta.ws.rs.Produces; -import org.eclipse.jetty.client.HttpClient; -import org.eclipse.jetty.client.WWWAuthenticationProtocolHandler; import org.eclipse.microprofile.config.inject.ConfigProperty; -import org.eclipse.microprofile.context.ManagedExecutor; - -import java.util.Arrays; @ApplicationScoped public class HttpClientModule { @Inject - ManagedExecutor executorService; + Vertx vertx; @Produces @ApplicationScoped - public JettyHttpClient provideHttpClient(@ConfigProperty(name = "httpClient.maxConnectionsQueued") Integer maxConnectionsQueued, + public VertxHttpClient provideHttpClient(@ConfigProperty(name = "httpClient.maxConnectionsQueued") Integer maxConnectionsQueued, @ConfigProperty(name = "httpClient.maxConnectionPerRoute") Integer maxConnectionPerRoute, @ConfigProperty(name = "httpClient.requestBufferSize") Integer requestBufferSize, @ConfigProperty(name = "httpClient.responseBufferSize") Integer responseBufferSize, @@ -29,45 +27,36 @@ public JettyHttpClient provideHttpClient(@ConfigProperty(name = "httpClient.maxC @ConfigProperty(name = "httpClient.disableWWWAuthenticationValidation") Boolean disableWWWAuthenticationValidation) { - try { - HttpClient httpClient = new HttpClient(); - httpClient.setExecutor(executorService); - httpClient.setMaxConnectionsPerDestination(maxConnectionsQueued); - httpClient.setMaxRequestsQueuedPerDestination(maxConnectionPerRoute); - httpClient.setRequestBufferSize(requestBufferSize); - httpClient.setResponseBufferSize(responseBufferSize); - httpClient.setMaxRedirects(maxRedirects); - httpClient.setIdleTimeout(idleTimeout); - httpClient.setConnectTimeout(connectTimeout); - httpClient.start(); + WebClientOptions options = new WebClientOptions(); - if (disableWWWAuthenticationValidation) { - httpClient.getProtocolHandlers().remove(WWWAuthenticationProtocolHandler.NAME); - } + // Mapping configuration + options.setMaxPoolSize(maxConnectionPerRoute); // Closest mapping to MaxConnectionsPerDestination/MaxRequestsQueuedPerDestination + // maxConnectionsQueued (Jetty) -> MaxWaitQueueSize (Vertx)? Vertx doesn't seem to have exact equivalent exposed in options simply. + // setExecutor is handled by Vertx instance. - registerHttpClientShutdownHook(httpClient); + // request/response buffer sizes are not directly configurable in WebClientOptions in the same way, + // but we can control some limits. For now, we might skip exact buffer size mapping unless critical. + // Jetty's setRequestBufferSize/setResponseBufferSize -> Vertx ? + // Vertx handles buffers dynamically mostly. - return new JettyHttpClient(httpClient); - } catch (Exception e) { - System.out.println(Arrays.toString(e.getStackTrace())); - throw new RuntimeException(e.getLocalizedMessage(), e); + options.setMaxRedirects(maxRedirects); + // Vertx: setIdleTimeout(int idleTimeout) - "The amount of time a connection can be idle before it is closed. 0 means no timeout." + // usually seconds in Vertx. + int idleTimeoutSeconds = idleTimeout / 1000; + if (idleTimeout > 0 && idleTimeoutSeconds == 0) { + idleTimeoutSeconds = 1; } - } + options.setIdleTimeout(idleTimeoutSeconds); + + options.setConnectTimeout(connectTimeout); // Vertx: setConnectTimeout(int connectTimeout) in ms. + + // disableWWWAuthenticationValidation -> Vertx handles auth differently. + // If this means disable automatic handling of 401, Vertx WebClient doesn't do it automatically unless configured. + + // We also need to consider KeepAlive which is usually true by default. + + WebClient webClient = WebClient.create(vertx, options); - private void registerHttpClientShutdownHook(final HttpClient httpClient) { - Runtime.getRuntime().addShutdownHook(new Thread("ShutdownHook_HttpClient") { - @Override - public void run() { - try { - if (!httpClient.isStopped()) { - httpClient.stop(); - } - } catch (Throwable e) { - String message = "HttpClient did not stop as expected."; - System.out.println(message); - System.out.println(Arrays.toString(e.getStackTrace())); - } - } - }); + return new VertxHttpClient(vertx, webClient); } } diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java b/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java index 295292a43..3b8b946d3 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java @@ -4,16 +4,16 @@ import ai.labs.eddi.engine.httpclient.IHttpClient; import ai.labs.eddi.engine.httpclient.IRequest; import ai.labs.eddi.engine.httpclient.IResponse; +import io.vertx.core.MultiMap; +import io.vertx.core.buffer.Buffer; +import io.vertx.ext.web.client.HttpRequest; +import io.vertx.ext.web.client.HttpResponse; +import io.vertx.ext.web.client.WebClient; import jakarta.enterprise.context.ApplicationScoped; import jakarta.inject.Inject; import lombok.EqualsAndHashCode; import lombok.Getter; import lombok.Setter; -import org.eclipse.jetty.client.*; -import org.eclipse.jetty.http.HttpCookieStore; -import org.eclipse.jetty.http.HttpField; -import org.eclipse.jetty.http.HttpFields; -import org.eclipse.jetty.http.HttpHeader; import org.eclipse.microprofile.config.inject.ConfigProperty; import org.jboss.logging.Logger; @@ -36,23 +36,18 @@ public class HttpClientWrapper implements IHttpClient { private static final String KEY_USER_AGENT = "userAgent"; private static final String KEY_MAX_LENGTH = "maxLength"; private static final int TEXT_LIMIT = 150; - private final HttpClient httpClient; + private final WebClient webClient; private final String userAgent; private static final Logger log = Logger.getLogger(HttpClientWrapper.class); @Inject - public HttpClientWrapper(JettyHttpClient httpClient, + public HttpClientWrapper(VertxHttpClient httpClient, @ConfigProperty(name = "systemRuntime.projectDomain") String projectDomain, @ConfigProperty(name = "systemRuntime.projectVersion") String projectVersion) { - this.httpClient = httpClient.getHttpClient(); + this.webClient = httpClient.getWebClient(); this.userAgent = projectDomain.toUpperCase() + "/" + projectVersion; } - @Override - public HttpCookieStore getCookieStore() { - return httpClient.getHttpCookieStore(); - } - @Override public IRequest newRequest(URI uri) { return newRequest(uri, Method.GET); @@ -60,127 +55,191 @@ public IRequest newRequest(URI uri) { @Override public IRequest newRequest(URI uri, Method method) { - var request = httpClient.newRequest(uri).method(method.name()). - headers(httpFields -> httpFields.put(HttpHeader.USER_AGENT, userAgent)); - return new RequestWrapper(uri, request); + io.vertx.core.http.HttpMethod vertxMethod = io.vertx.core.http.HttpMethod.valueOf(method.name()); + // WebClient's requestAbs handles absolute URIs + HttpRequest request = webClient.requestAbs(vertxMethod, uri.toString()); + request.putHeader("User-Agent", userAgent); + + return new RequestWrapper(uri, request, vertxMethod); } @Getter @EqualsAndHashCode private class RequestWrapper implements IRequest { private final URI uri; - private final Request request; + private final HttpRequest request; + private final io.vertx.core.http.HttpMethod method; private int maxLength = 8 * 1024 * 1024; private String requestBody; + private String requestEncoding; + private String requestContentType; + private final Map> queryParamsMap = new HashMap<>(); - RequestWrapper(URI uri, Request request) { + RequestWrapper(URI uri, HttpRequest request, io.vertx.core.http.HttpMethod method) { this.uri = uri; this.request = request; + this.method = method; + + // Parse initial query params from URI if any + String query = uri.getQuery(); + if (query != null && !query.isEmpty()) { + String[] pairs = query.split(KEY_LOGICAL_AND); + for (String pair : pairs) { + int idx = pair.indexOf(KEY_EQUALS); + String key = idx > 0 ? pair.substring(0, idx) : pair; + String value = idx > 0 && pair.length() > idx + 1 ? pair.substring(idx + 1) : null; + queryParamsMap.computeIfAbsent(key, k -> new ArrayList<>()).add(value); + } + } } @Override public IRequest setBasicAuthentication(String username, String password, String realm, boolean preemptive) { - if (preemptive) { - request.headers(httpFields -> httpFields.add("Authorization", "Basic " + Base64.getEncoder().encodeToString((username + ":" + password).getBytes()))); - } else { - AuthenticationStore auth = httpClient.getAuthenticationStore(); - auth.addAuthentication(new BasicAuthentication(uri, realm, username, password)); - } - - return this; + // Vert.x basic auth helper + request.basicAuthentication(username, password); + return this; } public IRequest setHttpHeader(String headerName, String value) { - request.headers(httpFields -> httpFields.add(headerName, value)); + request.putHeader(headerName, value); return this; } @Override public IRequest setQueryParam(String key, String value) { - request.param(key, value); + request.addQueryParam(key, value); + queryParamsMap.computeIfAbsent(key, k -> new ArrayList<>()).add(value); return this; } @Override public IRequest setUserAgent(String userAgent) { - request.agent(userAgent); + request.putHeader("User-Agent", userAgent); return this; } @Override public IRequest setBodyEntity(String content, String encoding, String contentType) { this.requestBody = content; - request.body(new StringRequestContent(contentType, this.requestBody, Charset.forName(encoding))); + this.requestEncoding = encoding; + this.requestContentType = contentType; + + if (contentType != null) { + request.putHeader("Content-Type", contentType); + } return this; } @Override public IRequest setMaxResponseSize(int maxLength) { this.maxLength = maxLength; - + // Vert.x doesn't have a direct "max response size" on the request builder that limits buffering + // automatically in the same way as Jetty's response listener might, but we can inspect content-length + // or handle it in a stream if needed. However, for standard buffer response, it just buffers. + // If we needed strict limiting, we might need to use sendStream and count bytes. + // For now, we will assume the buffer handles it or we check afterwards. + // Actually, `as(BodyCodec.string())` or similar doesn't limit. + // Given the previous implementation used `BufferingResponseListener` with a limit, + // we should be careful. But Vert.x WebClient buffers everything by default. return this; } @Override public IRequest setTimeout(long timeout, TimeUnit timeUnit) { - request.timeout(timeout, timeUnit); - + request.timeout(timeUnit.toMillis(timeout)); return this; } @Override public IResponse send() throws HttpRequestException { + CompletableFuture future = new CompletableFuture<>(); + + doSend(ar -> { + if (ar.succeeded()) { + future.complete(ar.result()); + } else { + future.completeExceptionally(ar.cause()); + } + }); + try { - var listener = new CompletableResponseListener(request, maxLength); - CompletableFuture completableFuture = listener.send(); - completableFuture.thenApply(ContentResponse::getContentAsString); - var response = completableFuture.get(); - var responseWrapper = new ResponseWrapper(); - responseWrapper.setContentAsString(response.getContentAsString()); - responseWrapper.setHttpCode(response.getStatus()); - responseWrapper.setHttpCodeMessage(response.getReason()); - responseWrapper.setHttpHeader(convertHeaderToMap(response.getHeaders())); - - return responseWrapper; + return future.get(); } catch (InterruptedException | ExecutionException e) { throw new HttpRequestException(e.getLocalizedMessage(), e); } } + private void doSend(io.vertx.core.Handler> handler) { + io.vertx.core.Future> future; + + if (requestBody != null) { + // If encoding is specified, we might need to encode it. + // But usually strings are just strings. + // If specific charset is needed for wire transmission: + if (requestEncoding != null) { + future = request.sendBuffer(Buffer.buffer(requestBody, requestEncoding)); + } else { + future = request.sendBuffer(Buffer.buffer(requestBody)); + } + } else { + future = request.send(); + } + + future.onComplete(ar -> { + if (ar.succeeded()) { + HttpResponse response = ar.result(); + Buffer body = response.body(); + if (body != null && body.length() > maxLength) { + String message = String.format("Response body length %d exceeds maximum allowed length %d", body.length(), maxLength); + log.warn(message); + // We could treat this as failure, but to be consistent with potentially just truncation or just warning, + // we'll just warn for now or truncate if we want to simulate buffering limit. + // The previous implementation 'BufferingResponseListener(maxLength)' would throw an exception if limit exceeded. + // So we should fail the future. + handler.handle(io.vertx.core.Future.failedFuture(new IResponse.HttpResponseException(message))); + return; + } + + ResponseWrapper responseWrapper = new ResponseWrapper(); + if (body != null) { + responseWrapper.setContentAsString(response.bodyAsString()); + } else { + responseWrapper.setContentAsString(""); + } + + responseWrapper.setHttpCode(response.statusCode()); + responseWrapper.setHttpCodeMessage(response.statusMessage()); + responseWrapper.setHttpHeader(convertHeaderToMap(response.headers())); + handler.handle(io.vertx.core.Future.succeededFuture(responseWrapper)); + } else { + handler.handle(io.vertx.core.Future.failedFuture(ar.cause())); + } + }); + } + @Override public Map toMap() { Map map = new HashMap<>(); // Add URI and HTTP method map.put(KEY_URI, uri.toString()); - map.put(KEY_METHOD, request.getMethod()); + map.put(KEY_METHOD, method.name()); // Add headers Map headers = new HashMap<>(); - request.getHeaders().forEach(field -> headers.put(field.getName(), field.getValue())); + request.headers().forEach(entry -> headers.put(entry.getKey(), entry.getValue())); map.put(KEY_HEADERS, headers); - // Add query parameters by parsing the URI - Map> queryParams = new HashMap<>(); - String query = uri.getQuery(); - if (query != null && !query.isEmpty()) { - String[] pairs = query.split(KEY_LOGICAL_AND); - for (String pair : pairs) { - int idx = pair.indexOf(KEY_EQUALS); - String key = idx > 0 ? pair.substring(0, idx) : pair; - String value = idx > 0 && pair.length() > idx + 1 ? pair.substring(idx + 1) : null; - queryParams.computeIfAbsent(key, k -> new ArrayList<>()).add(value); - } - } - map.put(KEY_QUERY_PARAMS, queryParams); + // Add query parameters + map.put(KEY_QUERY_PARAMS, queryParamsMap); // Add body if present if (requestBody != null) { map.put(KEY_BODY, requestBody); } - // Add user agent if present - String userAgent = request.getAgent(); + // Add user agent + String userAgent = request.headers().get("User-Agent"); if (userAgent != null) { map.put(KEY_USER_AGENT, userAgent); } @@ -194,35 +253,25 @@ public Map toMap() { @Override public void send(final ICompleteListener completeListener) { - final BufferingResponseListener responseListener = new BufferingResponseListener(maxLength) { - @Override - public void onComplete(final Result result) { - final Response response = result.getResponse(); - final String content = getContentAsString(); - + doSend(ar -> { + if (ar.succeeded()) { try { - var responseWrapper = new ResponseWrapper(); - responseWrapper.setContentAsString(content); - responseWrapper.setHttpCode(response.getStatus()); - responseWrapper.setHttpCodeMessage(response.getReason()); - responseWrapper.setHttpHeader(convertHeaderToMap(response.getHeaders())); - - completeListener.onComplete(responseWrapper); + completeListener.onComplete(ar.result()); } catch (IResponse.HttpResponseException e) { log.error(e.getLocalizedMessage(), e); } + } else { + log.error(ar.cause().getLocalizedMessage(), ar.cause()); } - }; - - request.send(responseListener); + }); } @Override public String toString() { - String requestBody = truncateAndClean(this.requestBody); + String requestBodyTruncated = truncateAndClean(this.requestBody); - return String.format("RequestWrapper{uri=%s, request=%s, requestBody=\"%s\", maxLength=%d, queryParams=%s}", - uri, request, requestBody, maxLength, request.getParams()); + return String.format("RequestWrapper{uri=%s, method=%s, requestBody=\"%s\", maxLength=%d, queryParams=%s}", + uri, method, requestBodyTruncated, maxLength, queryParamsMap); } } @@ -237,12 +286,12 @@ private static class ResponseWrapper implements IResponse { @Override public String toString() { - String contentAsString = truncateAndClean(this.contentAsString); + String contentAsStringTruncated = truncateAndClean(this.contentAsString); String httpHeaderString = httpHeader != null ? httpHeader.toString() : null; return String.format("ResponseWrapper{httpCode=%d, httpCodeMessage=\"%s\", responseBody=\"%s\", httpHeader=%s}", - httpCode, httpCodeMessage, contentAsString, httpHeaderString); + httpCode, httpCodeMessage, contentAsStringTruncated, httpHeaderString); } } @@ -259,10 +308,10 @@ private static String truncateAndClean(String text) { return text; } - private static Map convertHeaderToMap(HttpFields headers) { + private static Map convertHeaderToMap(MultiMap headers) { Map httpHeader = new HashMap<>(); - for (HttpField header : headers) { - httpHeader.put(header.getName(), header.getValue()); + for (Map.Entry header : headers) { + httpHeader.put(header.getKey(), header.getValue()); } return httpHeader; } diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/impl/JettyHttpClient.java b/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java similarity index 57% rename from src/main/java/ai/labs/eddi/engine/httpclient/impl/JettyHttpClient.java rename to src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java index 1a43e97a3..49f2ee7ee 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/impl/JettyHttpClient.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java @@ -1,15 +1,17 @@ package ai.labs.eddi.engine.httpclient.impl; +import io.vertx.core.Vertx; +import io.vertx.ext.web.client.WebClient; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; import lombok.Setter; -import org.eclipse.jetty.client.HttpClient; @NoArgsConstructor @AllArgsConstructor @Getter @Setter -public class JettyHttpClient { - private HttpClient httpClient; +public class VertxHttpClient { + private Vertx vertx; + private WebClient webClient; } From f7562b192248c8e9aed789510f3c9642064009fe Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 13:21:51 +0000 Subject: [PATCH 2/6] Migrate jetty-client to vertx-web-client Replaced jetty-client dependency with vertx-web-client (managed version). Refactored `IHttpClient` and `HttpClientWrapper` to use Vert.x WebClient. Updated `HttpClientModule` to configure `VertxHttpClient`. Implemented `WebClientSession` for cookie support. Enabled redirects and compression support. Restored max response size check in `HttpClientWrapper`. Addressed review feedback regarding versioning, blocking calls, and cookies. --- pom.xml | 1 - .../bootstrap/HttpClientModule.java | 24 ++++++------------- .../httpclient/impl/HttpClientWrapper.java | 4 ++-- .../httpclient/impl/VertxHttpClient.java | 3 ++- 4 files changed, 11 insertions(+), 21 deletions(-) diff --git a/pom.xml b/pom.xml index f5a780995..44ddd0c2d 100644 --- a/pom.xml +++ b/pom.xml @@ -269,7 +269,6 @@ io.vertx vertx-web-client - 5.0.5 jakarta.transaction diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java b/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java index 523f2e8b6..03e577948 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java @@ -3,6 +3,7 @@ import ai.labs.eddi.engine.httpclient.impl.VertxHttpClient; import io.vertx.core.Vertx; import io.vertx.ext.web.client.WebClient; +import io.vertx.ext.web.client.WebClientSession; import io.vertx.ext.web.client.WebClientOptions; import jakarta.enterprise.context.ApplicationScoped; import jakarta.inject.Inject; @@ -30,33 +31,22 @@ public VertxHttpClient provideHttpClient(@ConfigProperty(name = "httpClient.maxC WebClientOptions options = new WebClientOptions(); // Mapping configuration - options.setMaxPoolSize(maxConnectionPerRoute); // Closest mapping to MaxConnectionsPerDestination/MaxRequestsQueuedPerDestination - // maxConnectionsQueued (Jetty) -> MaxWaitQueueSize (Vertx)? Vertx doesn't seem to have exact equivalent exposed in options simply. - // setExecutor is handled by Vertx instance. - - // request/response buffer sizes are not directly configurable in WebClientOptions in the same way, - // but we can control some limits. For now, we might skip exact buffer size mapping unless critical. - // Jetty's setRequestBufferSize/setResponseBufferSize -> Vertx ? - // Vertx handles buffers dynamically mostly. + options.setMaxPoolSize(maxConnectionPerRoute); options.setMaxRedirects(maxRedirects); - // Vertx: setIdleTimeout(int idleTimeout) - "The amount of time a connection can be idle before it is closed. 0 means no timeout." - // usually seconds in Vertx. int idleTimeoutSeconds = idleTimeout / 1000; if (idleTimeout > 0 && idleTimeoutSeconds == 0) { idleTimeoutSeconds = 1; } options.setIdleTimeout(idleTimeoutSeconds); - options.setConnectTimeout(connectTimeout); // Vertx: setConnectTimeout(int connectTimeout) in ms. - - // disableWWWAuthenticationValidation -> Vertx handles auth differently. - // If this means disable automatic handling of 401, Vertx WebClient doesn't do it automatically unless configured. - - // We also need to consider KeepAlive which is usually true by default. + options.setConnectTimeout(connectTimeout); + options.setFollowRedirects(true); + options.setDecompressionSupported(true); WebClient webClient = WebClient.create(vertx, options); + WebClientSession webClientSession = WebClientSession.create(webClient); - return new VertxHttpClient(vertx, webClient); + return new VertxHttpClient(vertx, webClientSession); } } diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java b/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java index 3b8b946d3..6b894c1cc 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java @@ -8,7 +8,7 @@ import io.vertx.core.buffer.Buffer; import io.vertx.ext.web.client.HttpRequest; import io.vertx.ext.web.client.HttpResponse; -import io.vertx.ext.web.client.WebClient; +import io.vertx.ext.web.client.WebClientSession; import jakarta.enterprise.context.ApplicationScoped; import jakarta.inject.Inject; import lombok.EqualsAndHashCode; @@ -36,7 +36,7 @@ public class HttpClientWrapper implements IHttpClient { private static final String KEY_USER_AGENT = "userAgent"; private static final String KEY_MAX_LENGTH = "maxLength"; private static final int TEXT_LIMIT = 150; - private final WebClient webClient; + private final WebClientSession webClient; private final String userAgent; private static final Logger log = Logger.getLogger(HttpClientWrapper.class); diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java b/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java index 49f2ee7ee..95bfd6d26 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java @@ -2,6 +2,7 @@ import io.vertx.core.Vertx; import io.vertx.ext.web.client.WebClient; +import io.vertx.ext.web.client.WebClientSession; import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; @@ -13,5 +14,5 @@ @Setter public class VertxHttpClient { private Vertx vertx; - private WebClient webClient; + private WebClientSession webClient; } From 547e7b65e145caef1358e3d0ac97a702fd11ba51 Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 13:46:30 +0000 Subject: [PATCH 3/6] Remove unused disableWWWAuthenticationValidation parameter Removed the unused `disableWWWAuthenticationValidation` parameter from `HttpClientModule` as per code review feedback. This parameter was specific to Jetty client configuration and is not applicable to Vert.x WebClient in the current implementation. --- .../eddi/engine/httpclient/bootstrap/HttpClientModule.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java b/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java index 03e577948..a7366f62b 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java @@ -24,9 +24,7 @@ public VertxHttpClient provideHttpClient(@ConfigProperty(name = "httpClient.maxC @ConfigProperty(name = "httpClient.responseBufferSize") Integer responseBufferSize, @ConfigProperty(name = "httpClient.maxRedirects") Integer maxRedirects, @ConfigProperty(name = "httpClient.idleTimeoutInMillis") Integer idleTimeout, - @ConfigProperty(name = "httpClient.connectTimeoutInMillis") Integer connectTimeout, - @ConfigProperty(name = "httpClient.disableWWWAuthenticationValidation") - Boolean disableWWWAuthenticationValidation) { + @ConfigProperty(name = "httpClient.connectTimeoutInMillis") Integer connectTimeout) { WebClientOptions options = new WebClientOptions(); From db69e2c1759e4f6957c0d0085c0c1f457d1ecfc2 Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 14:12:48 +0000 Subject: [PATCH 4/6] Migrate from Jetty to Vert.x WebClient with proper error handling and memory safety - Replaced jetty-client with vertx-web-client managed by Quarkus BOM - Implemented IHttpClient using Vert.x WebClientSession for cookie persistence - Added memory safety checks using Content-Length header and post-download size verification - Refactored configuration handling to remove unused parameters - Fixed concurrency and interruption handling in sync requests --- .../bootstrap/HttpClientModule.java | 5 +- .../httpclient/impl/HttpClientWrapper.java | 103 +++++++++++------- .../httpclient/impl/VertxHttpClient.java | 1 - 3 files changed, 62 insertions(+), 47 deletions(-) diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java b/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java index a7366f62b..0cd95a219 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java @@ -18,10 +18,7 @@ public class HttpClientModule { @Produces @ApplicationScoped - public VertxHttpClient provideHttpClient(@ConfigProperty(name = "httpClient.maxConnectionsQueued") Integer maxConnectionsQueued, - @ConfigProperty(name = "httpClient.maxConnectionPerRoute") Integer maxConnectionPerRoute, - @ConfigProperty(name = "httpClient.requestBufferSize") Integer requestBufferSize, - @ConfigProperty(name = "httpClient.responseBufferSize") Integer responseBufferSize, + public VertxHttpClient provideHttpClient(@ConfigProperty(name = "httpClient.maxConnectionPerRoute") Integer maxConnectionPerRoute, @ConfigProperty(name = "httpClient.maxRedirects") Integer maxRedirects, @ConfigProperty(name = "httpClient.idleTimeoutInMillis") Integer idleTimeout, @ConfigProperty(name = "httpClient.connectTimeoutInMillis") Integer connectTimeout) { diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java b/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java index 6b894c1cc..4d69ad567 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java @@ -96,6 +96,7 @@ private class RequestWrapper implements IRequest { @Override public IRequest setBasicAuthentication(String username, String password, String realm, boolean preemptive) { // Vert.x basic auth helper + // realm and preemptive are not used in Vert.x basicAuthentication as it sets the header directly (preemptive) request.basicAuthentication(username, password); return this; } @@ -165,56 +166,64 @@ public IResponse send() throws HttpRequestException { try { return future.get(); } catch (InterruptedException | ExecutionException e) { + if (e instanceof InterruptedException) { + Thread.currentThread().interrupt(); + } throw new HttpRequestException(e.getLocalizedMessage(), e); } } private void doSend(io.vertx.core.Handler> handler) { - io.vertx.core.Future> future; - + // Use stream to handle large responses safely if (requestBody != null) { - // If encoding is specified, we might need to encode it. - // But usually strings are just strings. - // If specific charset is needed for wire transmission: - if (requestEncoding != null) { - future = request.sendBuffer(Buffer.buffer(requestBody, requestEncoding)); - } else { - future = request.sendBuffer(Buffer.buffer(requestBody)); - } + Buffer buffer = requestEncoding != null ? Buffer.buffer(requestBody, requestEncoding) : Buffer.buffer(requestBody); + request.sendBuffer(buffer, ar -> handleResponse(ar, handler)); } else { - future = request.send(); + request.send(ar -> handleResponse(ar, handler)); } + } - future.onComplete(ar -> { - if (ar.succeeded()) { - HttpResponse response = ar.result(); - Buffer body = response.body(); - if (body != null && body.length() > maxLength) { - String message = String.format("Response body length %d exceeds maximum allowed length %d", body.length(), maxLength); - log.warn(message); - // We could treat this as failure, but to be consistent with potentially just truncation or just warning, - // we'll just warn for now or truncate if we want to simulate buffering limit. - // The previous implementation 'BufferingResponseListener(maxLength)' would throw an exception if limit exceeded. - // So we should fail the future. - handler.handle(io.vertx.core.Future.failedFuture(new IResponse.HttpResponseException(message))); - return; - } - - ResponseWrapper responseWrapper = new ResponseWrapper(); - if (body != null) { - responseWrapper.setContentAsString(response.bodyAsString()); - } else { - responseWrapper.setContentAsString(""); - } - - responseWrapper.setHttpCode(response.statusCode()); - responseWrapper.setHttpCodeMessage(response.statusMessage()); - responseWrapper.setHttpHeader(convertHeaderToMap(response.headers())); - handler.handle(io.vertx.core.Future.succeededFuture(responseWrapper)); - } else { - handler.handle(io.vertx.core.Future.failedFuture(ar.cause())); - } - }); + private void handleResponse(io.vertx.core.AsyncResult> ar, io.vertx.core.Handler> handler) { + if (ar.succeeded()) { + HttpResponse response = ar.result(); + // Check Content-Length header if available + String contentLengthHeader = response.getHeader("Content-Length"); + if (contentLengthHeader != null) { + try { + long contentLength = Long.parseLong(contentLengthHeader); + if (contentLength > maxLength) { + String message = String.format("Response Content-Length %d exceeds maximum allowed length %d", contentLength, maxLength); + log.warn(message); + handler.handle(io.vertx.core.Future.failedFuture(new IResponse.HttpResponseException(message))); + return; + } + } catch (NumberFormatException e) { + // Ignore invalid content-length + } + } + + Buffer body = response.body(); + if (body != null && body.length() > maxLength) { + String message = String.format("Response body length %d exceeds maximum allowed length %d", body.length(), maxLength); + log.warn(message); + handler.handle(io.vertx.core.Future.failedFuture(new IResponse.HttpResponseException(message))); + return; + } + + ResponseWrapper responseWrapper = new ResponseWrapper(); + if (body != null) { + responseWrapper.setContentAsString(response.bodyAsString()); + } else { + responseWrapper.setContentAsString(""); + } + + responseWrapper.setHttpCode(response.statusCode()); + responseWrapper.setHttpCodeMessage(response.statusMessage()); + responseWrapper.setHttpHeader(convertHeaderToMap(response.headers())); + handler.handle(io.vertx.core.Future.succeededFuture(responseWrapper)); + } else { + handler.handle(io.vertx.core.Future.failedFuture(ar.cause())); + } } @Override @@ -261,7 +270,17 @@ public void send(final ICompleteListener completeListener) { log.error(e.getLocalizedMessage(), e); } } else { - log.error(ar.cause().getLocalizedMessage(), ar.cause()); + log.error(ar.cause().getLocalizedMessage(), ar.cause()); + // Attempt to notify listener of failure via a 500 response if possible, + // strictly speaking ICompleteListener expects a response. + ResponseWrapper errorResponse = new ResponseWrapper(); + errorResponse.setHttpCode(500); + errorResponse.setHttpCodeMessage(ar.cause().getLocalizedMessage()); + try { + completeListener.onComplete(errorResponse); + } catch (IResponse.HttpResponseException e) { + log.error("Error while calling onComplete with error response", e); + } } }); } diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java b/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java index 95bfd6d26..47a5d03c1 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java @@ -1,7 +1,6 @@ package ai.labs.eddi.engine.httpclient.impl; import io.vertx.core.Vertx; -import io.vertx.ext.web.client.WebClient; import io.vertx.ext.web.client.WebClientSession; import lombok.AllArgsConstructor; import lombok.Getter; From fe097ebcaa4d4eb9009c067f229dd1b683e9f1a8 Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 14:39:43 +0000 Subject: [PATCH 5/6] Address review feedback for Vert.x WebClient migration - HttpClientModule: Added disposer method to close WebClient on destruction. - HttpClientWrapper: - Updated buffering vs streaming comments. - Wrapped encoding buffer creation in try-catch. - Implemented timeout for synchronous send() to prevent indefinite blocking. - Changed error response status from 500 to 503 (Service Unavailable). - Documented ignored Basic Auth parameters (realm, preemptive). --- .../bootstrap/HttpClientModule.java | 7 +++++ .../httpclient/impl/HttpClientWrapper.java | 30 ++++++++++++++----- 2 files changed, 29 insertions(+), 8 deletions(-) diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java b/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java index 0cd95a219..757f81cdc 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java @@ -6,6 +6,7 @@ import io.vertx.ext.web.client.WebClientSession; import io.vertx.ext.web.client.WebClientOptions; import jakarta.enterprise.context.ApplicationScoped; +import jakarta.enterprise.inject.Disposes; import jakarta.inject.Inject; import jakarta.ws.rs.Produces; import org.eclipse.microprofile.config.inject.ConfigProperty; @@ -44,4 +45,10 @@ public VertxHttpClient provideHttpClient(@ConfigProperty(name = "httpClient.maxC return new VertxHttpClient(vertx, webClientSession); } + + public void close(@Disposes VertxHttpClient client) { + if (client.getWebClient() != null) { + client.getWebClient().close(); + } + } } diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java b/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java index 4d69ad567..bb51b0a28 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java @@ -73,6 +73,7 @@ private class RequestWrapper implements IRequest { private String requestBody; private String requestEncoding; private String requestContentType; + private long currentTimeout = 60000; // Default timeout fallback private final Map> queryParamsMap = new HashMap<>(); RequestWrapper(URI uri, HttpRequest request, io.vertx.core.http.HttpMethod method) { @@ -96,7 +97,8 @@ private class RequestWrapper implements IRequest { @Override public IRequest setBasicAuthentication(String username, String password, String realm, boolean preemptive) { // Vert.x basic auth helper - // realm and preemptive are not used in Vert.x basicAuthentication as it sets the header directly (preemptive) + // Note: 'realm' and 'preemptive' parameters are ignored by Vert.x WebClient's basicAuthentication helper. + // It automatically sets the Authorization header (equivalent to preemptive=true). request.basicAuthentication(username, password); return this; } @@ -147,7 +149,9 @@ public IRequest setMaxResponseSize(int maxLength) { @Override public IRequest setTimeout(long timeout, TimeUnit timeUnit) { - request.timeout(timeUnit.toMillis(timeout)); + long timeoutMillis = timeUnit.toMillis(timeout); + this.currentTimeout = timeoutMillis; + request.timeout(timeoutMillis); return this; } @@ -164,7 +168,11 @@ public IResponse send() throws HttpRequestException { }); try { - return future.get(); + // Use a timeout slightly larger than the request timeout to ensure we don't block indefinitely + // if the callback never fires (though Vert.x should handle the timeout). + return future.get(currentTimeout + 1000, TimeUnit.MILLISECONDS); + } catch (java.util.concurrent.TimeoutException e) { + throw new HttpRequestException("Request timed out while waiting for response", e); } catch (InterruptedException | ExecutionException e) { if (e instanceof InterruptedException) { Thread.currentThread().interrupt(); @@ -174,9 +182,15 @@ public IResponse send() throws HttpRequestException { } private void doSend(io.vertx.core.Handler> handler) { - // Use stream to handle large responses safely + // Buffer entire response in memory; check size limits in handleResponse to mitigate large responses. if (requestBody != null) { - Buffer buffer = requestEncoding != null ? Buffer.buffer(requestBody, requestEncoding) : Buffer.buffer(requestBody); + Buffer buffer; + try { + buffer = requestEncoding != null ? Buffer.buffer(requestBody, requestEncoding) : Buffer.buffer(requestBody); + } catch (IllegalArgumentException e) { + handler.handle(io.vertx.core.Future.failedFuture(new HttpRequestException("Invalid encoding: " + requestEncoding, e))); + return; + } request.sendBuffer(buffer, ar -> handleResponse(ar, handler)); } else { request.send(ar -> handleResponse(ar, handler)); @@ -271,11 +285,11 @@ public void send(final ICompleteListener completeListener) { } } else { log.error(ar.cause().getLocalizedMessage(), ar.cause()); - // Attempt to notify listener of failure via a 500 response if possible, + // Attempt to notify listener of failure via a 503 response. // strictly speaking ICompleteListener expects a response. ResponseWrapper errorResponse = new ResponseWrapper(); - errorResponse.setHttpCode(500); - errorResponse.setHttpCodeMessage(ar.cause().getLocalizedMessage()); + errorResponse.setHttpCode(503); + errorResponse.setHttpCodeMessage("Service Unavailable: " + ar.cause().getLocalizedMessage()); try { completeListener.onComplete(errorResponse); } catch (IResponse.HttpResponseException e) { From 253edb08489616da1e9b5509eef4582474ead064 Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Sat, 22 Nov 2025 15:09:01 +0000 Subject: [PATCH 6/6] Address final review feedback for Vert.x WebClient migration - HttpClientModule: - Store and close the underlying WebClient to ensure proper resource management. - Improve idle timeout conversion logic (use ceil for milliseconds). - HttpClientWrapper: - Unwrap ExecutionException to expose root cause. - URL-decode query parameters during parsing. - Remove unused requestContentType field. - Clarify and condense comments regarding buffering and Basic Auth limitations. - Add warning about non-reusability of RequestWrapper. - VertxHttpClient: - Added field to hold underlying WebClient. --- .../bootstrap/HttpClientModule.java | 15 +++++---- .../httpclient/impl/HttpClientWrapper.java | 32 ++++++++++++------- .../httpclient/impl/VertxHttpClient.java | 2 ++ 3 files changed, 31 insertions(+), 18 deletions(-) diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java b/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java index 757f81cdc..79af88e19 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/bootstrap/HttpClientModule.java @@ -30,9 +30,12 @@ public VertxHttpClient provideHttpClient(@ConfigProperty(name = "httpClient.maxC options.setMaxPoolSize(maxConnectionPerRoute); options.setMaxRedirects(maxRedirects); - int idleTimeoutSeconds = idleTimeout / 1000; - if (idleTimeout > 0 && idleTimeoutSeconds == 0) { - idleTimeoutSeconds = 1; + + int idleTimeoutSeconds; + if (idleTimeout == 0) { + idleTimeoutSeconds = 0; + } else { + idleTimeoutSeconds = (int) Math.ceil(idleTimeout / 1000.0); } options.setIdleTimeout(idleTimeoutSeconds); @@ -43,12 +46,12 @@ public VertxHttpClient provideHttpClient(@ConfigProperty(name = "httpClient.maxC WebClient webClient = WebClient.create(vertx, options); WebClientSession webClientSession = WebClientSession.create(webClient); - return new VertxHttpClient(vertx, webClientSession); + return new VertxHttpClient(vertx, webClientSession, webClient); } public void close(@Disposes VertxHttpClient client) { - if (client.getWebClient() != null) { - client.getWebClient().close(); + if (client.getUnderlyingClient() != null) { + client.getUnderlyingClient().close(); } } } diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java b/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java index bb51b0a28..1b4167554 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/impl/HttpClientWrapper.java @@ -18,7 +18,9 @@ import org.jboss.logging.Logger; import java.net.URI; +import java.net.URLDecoder; import java.nio.charset.Charset; +import java.nio.charset.StandardCharsets; import java.util.*; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; @@ -63,6 +65,14 @@ public IRequest newRequest(URI uri, Method method) { return new RequestWrapper(uri, request, vertxMethod); } + /** + * Wrapper for Vert.x HttpRequest. + *

+ * Note: This class is stateful and wraps a mutable {@link HttpRequest}. + * It is designed to be used for a single request configuration and execution. + * Reusing an instance of this class for multiple {@code send()} calls may result in + * accumulated headers or query parameters. + */ @Getter @EqualsAndHashCode private class RequestWrapper implements IRequest { @@ -72,7 +82,6 @@ private class RequestWrapper implements IRequest { private int maxLength = 8 * 1024 * 1024; private String requestBody; private String requestEncoding; - private String requestContentType; private long currentTimeout = 60000; // Default timeout fallback private final Map> queryParamsMap = new HashMap<>(); @@ -89,6 +98,10 @@ private class RequestWrapper implements IRequest { int idx = pair.indexOf(KEY_EQUALS); String key = idx > 0 ? pair.substring(0, idx) : pair; String value = idx > 0 && pair.length() > idx + 1 ? pair.substring(idx + 1) : null; + + if (key != null) key = URLDecoder.decode(key, StandardCharsets.UTF_8); + if (value != null) value = URLDecoder.decode(value, StandardCharsets.UTF_8); + queryParamsMap.computeIfAbsent(key, k -> new ArrayList<>()).add(value); } } @@ -99,6 +112,7 @@ public IRequest setBasicAuthentication(String username, String password, String // Vert.x basic auth helper // Note: 'realm' and 'preemptive' parameters are ignored by Vert.x WebClient's basicAuthentication helper. // It automatically sets the Authorization header (equivalent to preemptive=true). + // WARNING: Non-preemptive authentication (preemptive=false) is NOT supported in this implementation. request.basicAuthentication(username, password); return this; } @@ -125,7 +139,6 @@ public IRequest setUserAgent(String userAgent) { public IRequest setBodyEntity(String content, String encoding, String contentType) { this.requestBody = content; this.requestEncoding = encoding; - this.requestContentType = contentType; if (contentType != null) { request.putHeader("Content-Type", contentType); @@ -136,14 +149,8 @@ public IRequest setBodyEntity(String content, String encoding, String contentTyp @Override public IRequest setMaxResponseSize(int maxLength) { this.maxLength = maxLength; - // Vert.x doesn't have a direct "max response size" on the request builder that limits buffering - // automatically in the same way as Jetty's response listener might, but we can inspect content-length - // or handle it in a stream if needed. However, for standard buffer response, it just buffers. - // If we needed strict limiting, we might need to use sendStream and count bytes. - // For now, we will assume the buffer handles it or we check afterwards. - // Actually, `as(BodyCodec.string())` or similar doesn't limit. - // Given the previous implementation used `BufferingResponseListener` with a limit, - // we should be careful. But Vert.x WebClient buffers everything by default. + // Note: Vert.x WebClient buffers the entire response by default. + // Size limits are validated in handleResponse() after the response is received. return this; } @@ -177,7 +184,8 @@ public IResponse send() throws HttpRequestException { if (e instanceof InterruptedException) { Thread.currentThread().interrupt(); } - throw new HttpRequestException(e.getLocalizedMessage(), e); + Throwable cause = (e instanceof ExecutionException && e.getCause() != null) ? e.getCause() : e; + throw new HttpRequestException(cause.getLocalizedMessage(), cause); } } @@ -286,7 +294,7 @@ public void send(final ICompleteListener completeListener) { } else { log.error(ar.cause().getLocalizedMessage(), ar.cause()); // Attempt to notify listener of failure via a 503 response. - // strictly speaking ICompleteListener expects a response. + // Strictly speaking ICompleteListener expects a response. ResponseWrapper errorResponse = new ResponseWrapper(); errorResponse.setHttpCode(503); errorResponse.setHttpCodeMessage("Service Unavailable: " + ar.cause().getLocalizedMessage()); diff --git a/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java b/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java index 47a5d03c1..b3954db93 100644 --- a/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java +++ b/src/main/java/ai/labs/eddi/engine/httpclient/impl/VertxHttpClient.java @@ -1,6 +1,7 @@ package ai.labs.eddi.engine.httpclient.impl; import io.vertx.core.Vertx; +import io.vertx.ext.web.client.WebClient; import io.vertx.ext.web.client.WebClientSession; import lombok.AllArgsConstructor; import lombok.Getter; @@ -14,4 +15,5 @@ public class VertxHttpClient { private Vertx vertx; private WebClientSession webClient; + private WebClient underlyingClient; }