Some kludge code to debug gateleen

4 files changed, 1036 insertions, 0 deletions

diff --git a/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateHttpServerRequest.java b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateHttpServerRequest.java
new file mode 100644
index 0000000..aa4ad48
--- /dev/null
+++ b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateHttpServerRequest.java
@@ -0,0 +1,394 @@
+package ch.hiddenalpha.unspecifiedgarbage.gateleenKludge.tmoutissue20240123;
+
+import io.netty.handler.codec.DecoderResult;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Future;
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.http.Cookie;
+import io.vertx.core.http.HttpConnection;
+import io.vertx.core.http.HttpFrame;
+import io.vertx.core.http.HttpMethod;
+import io.vertx.core.http.HttpServerFileUpload;
+import io.vertx.core.http.HttpServerRequest;
+import io.vertx.core.http.HttpServerResponse;
+import io.vertx.core.http.HttpVersion;
+import io.vertx.core.http.ServerWebSocket;
+import io.vertx.core.http.StreamPriority;
+import io.vertx.core.net.NetSocket;
+import io.vertx.core.net.SocketAddress;
+import io.vertx.core.streams.Pipe;
+import io.vertx.core.streams.WriteStream;
+
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+import javax.security.cert.X509Certificate;
+import java.util.Map;
+import java.util.Set;
+
+public class DelegateHttpServerRequest implements io.vertx.core.http.HttpServerRequest {
+
+    private final io.vertx.core.http.HttpServerRequest delegate;
+    private final boolean isDebugging = true;
+
+    public DelegateHttpServerRequest(HttpServerRequest delegate) {
+        this.delegate = delegate;
+    }
+
+    private void breakpoint(){
+        try{
+            throw new UnsupportedOperationException();
+        }catch(UnsupportedOperationException ex){}
+    }
+
+    @Override
+    public HttpServerRequest exceptionHandler(Handler<Throwable> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.exceptionHandler(handler);
+    }
+
+    @Override
+    public HttpServerRequest handler(Handler<Buffer> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.handler(handler);
+    }
+
+    @Override
+    public HttpServerRequest pause() {
+        if( isDebugging ) breakpoint();
+        return delegate.pause();
+    }
+
+    @Override
+    public HttpServerRequest resume() {
+        if( isDebugging ) breakpoint();
+        return delegate.resume();
+    }
+
+    @Override
+    public HttpServerRequest fetch(long amount) {
+        if( isDebugging ) breakpoint();
+        return delegate.fetch(amount);
+    }
+
+    @Override
+    public HttpServerRequest endHandler(Handler<Void> endHandler) {
+        if( isDebugging ) breakpoint();
+        return delegate.endHandler(endHandler);
+    }
+
+    @Override
+    public HttpVersion version() {
+        if( isDebugging ) breakpoint();
+        return delegate.version();
+    }
+
+    @Override
+    public HttpMethod method() {
+        if( isDebugging ) breakpoint();
+        return delegate.method();
+    }
+
+    @Override
+    public boolean isSSL() {
+        if( isDebugging ) breakpoint();
+        return delegate.isSSL();
+    }
+
+    @Override
+    public String scheme() {
+        if( isDebugging ) breakpoint();
+        return delegate.scheme();
+    }
+
+    @Override
+    public String uri() {
+        if( isDebugging ) breakpoint();
+        return delegate.uri();
+    }
+
+    @Override
+    public String path() {
+        if( isDebugging ) breakpoint();
+        return delegate.path();
+    }
+
+    @Override
+    public String query() {
+        if( isDebugging ) breakpoint();
+        return delegate.query();
+    }
+
+    @Override
+    public String host() {
+        if( isDebugging ) breakpoint();
+        return delegate.host();
+    }
+
+    @Override
+    public long bytesRead() {
+        if( isDebugging ) breakpoint();
+        return delegate.bytesRead();
+    }
+
+    @Override
+    public HttpServerResponse response() {
+        if( isDebugging ) breakpoint();
+        return delegate.response();
+    }
+
+    @Override
+    public MultiMap headers() {
+        if( isDebugging ) breakpoint();
+        return delegate.headers();
+    }
+
+    @Override
+    public String getHeader(String headerName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getHeader(headerName);
+    }
+
+    @Override
+    public String getHeader(CharSequence headerName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getHeader(headerName);
+    }
+
+    @Override
+    public MultiMap params() {
+        if( isDebugging ) breakpoint();
+        return delegate.params();
+    }
+
+    @Override
+    public String getParam(String paramName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getParam(paramName);
+    }
+
+    @Override
+    public String getParam(String paramName, String defaultValue) {
+        if( isDebugging ) breakpoint();
+        return delegate.getParam(paramName, defaultValue);
+    }
+
+    @Override
+    public SocketAddress remoteAddress() {
+        if( isDebugging ) breakpoint();
+        return delegate.remoteAddress();
+    }
+
+    @Override
+    public SocketAddress localAddress() {
+        if( isDebugging ) breakpoint();
+        return delegate.localAddress();
+    }
+
+    @Override
+    public SSLSession sslSession() {
+        if( isDebugging ) breakpoint();
+        return delegate.sslSession();
+    }
+
+    @Override
+    public X509Certificate[] peerCertificateChain() throws SSLPeerUnverifiedException {
+        if( isDebugging ) breakpoint();
+        return delegate.peerCertificateChain();
+    }
+
+    @Override
+    public String absoluteURI() {
+        if( isDebugging ) breakpoint();
+        return delegate.absoluteURI();
+    }
+
+    @Override
+    public HttpServerRequest bodyHandler(Handler<Buffer> bodyHandler) {
+        if( isDebugging ) breakpoint();
+        return delegate.bodyHandler(bodyHandler);
+    }
+
+    @Override
+    public HttpServerRequest body(Handler<AsyncResult<Buffer>> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.body(handler);
+    }
+
+    @Override
+    public Future<Buffer> body() {
+        if( isDebugging ) breakpoint();
+        return delegate.body();
+    }
+
+    @Override
+    public void end(Handler<AsyncResult<Void>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.end(handler);
+    }
+
+    @Override
+    public Future<Void> end() {
+        if( isDebugging ) breakpoint();
+        return delegate.end();
+    }
+
+    @Override
+    public void toNetSocket(Handler<AsyncResult<NetSocket>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.toNetSocket(handler);
+    }
+
+    @Override
+    public Future<NetSocket> toNetSocket() {
+        if( isDebugging ) breakpoint();
+        return delegate.toNetSocket();
+    }
+
+    @Override
+    public HttpServerRequest setExpectMultipart(boolean expect) {
+        if( isDebugging ) breakpoint();
+        return delegate.setExpectMultipart(expect);
+    }
+
+    @Override
+    public boolean isExpectMultipart() {
+        if( isDebugging ) breakpoint();
+        return delegate.isExpectMultipart();
+    }
+
+    @Override
+    public HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler) {
+        if( isDebugging ) breakpoint();
+        return delegate.uploadHandler(uploadHandler);
+    }
+
+    @Override
+    public MultiMap formAttributes() {
+        if( isDebugging ) breakpoint();
+        return delegate.formAttributes();
+    }
+
+    @Override
+    public String getFormAttribute(String attributeName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getFormAttribute(attributeName);
+    }
+
+    @Override
+    public int streamId() {
+        if( isDebugging ) breakpoint();
+        return delegate.streamId();
+    }
+
+    @Override
+    public void toWebSocket(Handler<AsyncResult<ServerWebSocket>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.toWebSocket(handler);
+    }
+
+    @Override
+    public Future<ServerWebSocket> toWebSocket() {
+        if( isDebugging ) breakpoint();
+        return delegate.toWebSocket();
+    }
+
+    @Override
+    public boolean isEnded() {
+        if( isDebugging ) breakpoint();
+        return delegate.isEnded();
+    }
+
+    @Override
+    public HttpServerRequest customFrameHandler(Handler<HttpFrame> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.customFrameHandler(handler);
+    }
+
+    @Override
+    public HttpConnection connection() {
+        if( isDebugging ) breakpoint();
+        return delegate.connection();
+    }
+
+    @Override
+    public StreamPriority streamPriority() {
+        if( isDebugging ) breakpoint();
+        return delegate.streamPriority();
+    }
+
+    @Override
+    public HttpServerRequest streamPriorityHandler(Handler<StreamPriority> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.streamPriorityHandler(handler);
+    }
+
+    @Override
+    public DecoderResult decoderResult() {
+        if( isDebugging ) breakpoint();
+        return delegate.decoderResult();
+    }
+
+    @Override
+    public Cookie getCookie(String name) {
+        if( isDebugging ) breakpoint();
+        return delegate.getCookie(name);
+    }
+
+    @Override
+    public Cookie getCookie(String name, String domain, String path) {
+        if( isDebugging ) breakpoint();
+        return delegate.getCookie(name, domain, path);
+    }
+
+    @Override
+    public int cookieCount() {
+        if( isDebugging ) breakpoint();
+        return delegate.cookieCount();
+    }
+
+    @Override
+    @Deprecated
+    public Map<String, Cookie> cookieMap() {
+        if( isDebugging ) breakpoint();
+        return delegate.cookieMap();
+    }
+
+    @Override
+    public Set<Cookie> cookies(String name) {
+        if( isDebugging ) breakpoint();
+        return delegate.cookies(name);
+    }
+
+    @Override
+    public Set<Cookie> cookies() {
+        if( isDebugging ) breakpoint();
+        return delegate.cookies();
+    }
+
+    @Override
+    public HttpServerRequest routed(String route) {
+        if( isDebugging ) breakpoint();
+        return delegate.routed(route);
+    }
+
+    @Override
+    public Pipe<Buffer> pipe() {
+        if( isDebugging ) breakpoint();
+        return delegate.pipe();
+    }
+
+    @Override
+    public Future<Void> pipeTo(WriteStream<Buffer> dst) {
+        if( isDebugging ) breakpoint();
+        return delegate.pipeTo(dst);
+    }
+
+    @Override
+    public void pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.pipeTo(dst, handler);
+    }
+
+}
diff --git a/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateVertxHttpServerRequestInternal.java b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateVertxHttpServerRequestInternal.java
new file mode 100644
index 0000000..16c7259
--- /dev/null
+++ b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateVertxHttpServerRequestInternal.java
@@ -0,0 +1,408 @@
+package ch.hiddenalpha.unspecifiedgarbage.gateleenKludge.tmoutissue20240123;
+
+import io.netty.handler.codec.DecoderResult;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Context;
+import io.vertx.core.Future;
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.http.Cookie;
+import io.vertx.core.http.HttpConnection;
+import io.vertx.core.http.HttpFrame;
+import io.vertx.core.http.HttpMethod;
+import io.vertx.core.http.HttpServerFileUpload;
+import io.vertx.core.http.HttpServerRequest;
+import io.vertx.core.http.HttpServerResponse;
+import io.vertx.core.http.HttpVersion;
+import io.vertx.core.http.ServerWebSocket;
+import io.vertx.core.http.StreamPriority;
+import io.vertx.core.http.impl.HttpServerRequestInternal;
+import io.vertx.core.net.NetSocket;
+import io.vertx.core.net.SocketAddress;
+import io.vertx.core.streams.Pipe;
+import io.vertx.core.streams.WriteStream;
+
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+import javax.security.cert.X509Certificate;
+import java.util.Map;
+import java.util.Set;
+
+public class DelegateVertxHttpServerRequestInternal implements HttpServerRequestInternal {
+
+    private final HttpServerRequestInternal delegate;
+    private final boolean isDebugging = true;
+
+    public DelegateVertxHttpServerRequestInternal(HttpServerRequest delegate) {
+        this.delegate = (HttpServerRequestInternal) delegate;
+    }
+
+    private void breakpoint(){
+        try{
+            throw new UnsupportedOperationException();
+        }catch(UnsupportedOperationException ex){}
+    }
+
+    @Override
+    public HttpServerRequest exceptionHandler(Handler<Throwable> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.exceptionHandler(handler);
+    }
+
+    @Override
+    public HttpServerRequest handler(Handler<Buffer> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.handler(handler);
+    }
+
+    @Override
+    public HttpServerRequest pause() {
+        if( isDebugging ) breakpoint();
+        return delegate.pause();
+    }
+
+    @Override
+    public HttpServerRequest resume() {
+        if( isDebugging ) breakpoint();
+        return delegate.resume();
+    }
+
+    @Override
+    public HttpServerRequest fetch(long amount) {
+        if( isDebugging ) breakpoint();
+        return delegate.fetch(amount);
+    }
+
+    @Override
+    public HttpServerRequest endHandler(Handler<Void> endHandler) {
+        if( isDebugging ) breakpoint();
+        return delegate.endHandler(endHandler);
+    }
+
+    @Override
+    public HttpVersion version() {
+        if( isDebugging ) breakpoint();
+        return delegate.version();
+    }
+
+    @Override
+    public HttpMethod method() {
+        if( isDebugging ) breakpoint();
+        return delegate.method();
+    }
+
+    @Override
+    public boolean isSSL() {
+        if( isDebugging ) breakpoint();
+        return delegate.isSSL();
+    }
+
+    @Override
+    public String scheme() {
+        if( isDebugging ) breakpoint();
+        return delegate.scheme();
+    }
+
+    @Override
+    public String uri() {
+        if( isDebugging ) breakpoint();
+        return delegate.uri();
+    }
+
+    @Override
+    public String path() {
+        if( isDebugging ) breakpoint();
+        return delegate.path();
+    }
+
+    @Override
+    public String query() {
+        if( isDebugging ) breakpoint();
+        return delegate.query();
+    }
+
+    @Override
+    public String host() {
+        if( isDebugging ) breakpoint();
+        return delegate.host();
+    }
+
+    @Override
+    public long bytesRead() {
+        if( isDebugging ) breakpoint();
+        return delegate.bytesRead();
+    }
+
+    @Override
+    public HttpServerResponse response() {
+        if( isDebugging ) breakpoint();
+        return delegate.response();
+    }
+
+    @Override
+    public MultiMap headers() {
+        if( isDebugging ) breakpoint();
+        return delegate.headers();
+    }
+
+    @Override
+    public String getHeader(String headerName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getHeader(headerName);
+    }
+
+    @Override
+    public String getHeader(CharSequence headerName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getHeader(headerName);
+    }
+
+    @Override
+    public MultiMap params() {
+        if( isDebugging ) breakpoint();
+        return delegate.params();
+    }
+
+    @Override
+    public String getParam(String paramName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getParam(paramName);
+    }
+
+    @Override
+    public String getParam(String paramName, String defaultValue) {
+        if( isDebugging ) breakpoint();
+        return delegate.getParam(paramName, defaultValue);
+    }
+
+    @Override
+    public SocketAddress remoteAddress() {
+        if( isDebugging ) breakpoint();
+        return delegate.remoteAddress();
+    }
+
+    @Override
+    public SocketAddress localAddress() {
+        if( isDebugging ) breakpoint();
+        return delegate.localAddress();
+    }
+
+    @Override
+    public SSLSession sslSession() {
+        if( isDebugging ) breakpoint();
+        return delegate.sslSession();
+    }
+
+    @Override
+    public X509Certificate[] peerCertificateChain() throws SSLPeerUnverifiedException {
+        if( isDebugging ) breakpoint();
+        return delegate.peerCertificateChain();
+    }
+
+    @Override
+    public String absoluteURI() {
+        if( isDebugging ) breakpoint();
+        return delegate.absoluteURI();
+    }
+
+    @Override
+    public HttpServerRequest bodyHandler(Handler<Buffer> bodyHandler) {
+        if( isDebugging ) breakpoint();
+        return delegate.bodyHandler(bodyHandler);
+    }
+
+    @Override
+    public HttpServerRequest body(Handler<AsyncResult<Buffer>> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.body(handler);
+    }
+
+    @Override
+    public Future<Buffer> body() {
+        if( isDebugging ) breakpoint();
+        return delegate.body();
+    }
+
+    @Override
+    public void end(Handler<AsyncResult<Void>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.end(handler);
+    }
+
+    @Override
+    public Future<Void> end() {
+        if( isDebugging ) breakpoint();
+        return delegate.end();
+    }
+
+    @Override
+    public void toNetSocket(Handler<AsyncResult<NetSocket>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.toNetSocket(handler);
+    }
+
+    @Override
+    public Future<NetSocket> toNetSocket() {
+        if( isDebugging ) breakpoint();
+        return delegate.toNetSocket();
+    }
+
+    @Override
+    public HttpServerRequest setExpectMultipart(boolean expect) {
+        if( isDebugging ) breakpoint();
+        return delegate.setExpectMultipart(expect);
+    }
+
+    @Override
+    public boolean isExpectMultipart() {
+        if( isDebugging ) breakpoint();
+        return delegate.isExpectMultipart();
+    }
+
+    @Override
+    public HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler) {
+        if( isDebugging ) breakpoint();
+        return delegate.uploadHandler(uploadHandler);
+    }
+
+    @Override
+    public MultiMap formAttributes() {
+        if( isDebugging ) breakpoint();
+        return delegate.formAttributes();
+    }
+
+    @Override
+    public String getFormAttribute(String attributeName) {
+        if( isDebugging ) breakpoint();
+        return delegate.getFormAttribute(attributeName);
+    }
+
+    @Override
+    public int streamId() {
+        if( isDebugging ) breakpoint();
+        return delegate.streamId();
+    }
+
+    @Override
+    public void toWebSocket(Handler<AsyncResult<ServerWebSocket>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.toWebSocket(handler);
+    }
+
+    @Override
+    public Future<ServerWebSocket> toWebSocket() {
+        if( isDebugging ) breakpoint();
+        return delegate.toWebSocket();
+    }
+
+    @Override
+    public boolean isEnded() {
+        if( isDebugging ) breakpoint();
+        return delegate.isEnded();
+    }
+
+    @Override
+    public HttpServerRequest customFrameHandler(Handler<HttpFrame> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.customFrameHandler(handler);
+    }
+
+    @Override
+    public HttpConnection connection() {
+        if( isDebugging ) breakpoint();
+        return delegate.connection();
+    }
+
+    @Override
+    public StreamPriority streamPriority() {
+        if( isDebugging ) breakpoint();
+        return delegate.streamPriority();
+    }
+
+    @Override
+    public HttpServerRequest streamPriorityHandler(Handler<StreamPriority> handler) {
+        if( isDebugging ) breakpoint();
+        return delegate.streamPriorityHandler(handler);
+    }
+
+    @Override
+    public DecoderResult decoderResult() {
+        if( isDebugging ) breakpoint();
+        return delegate.decoderResult();
+    }
+
+    @Override
+    public Cookie getCookie(String name) {
+        if( isDebugging ) breakpoint();
+        return delegate.getCookie(name);
+    }
+
+    @Override
+    public Cookie getCookie(String name, String domain, String path) {
+        if( isDebugging ) breakpoint();
+        return delegate.getCookie(name, domain, path);
+    }
+
+    @Override
+    public int cookieCount() {
+        if( isDebugging ) breakpoint();
+        return delegate.cookieCount();
+    }
+
+    @Override
+    @Deprecated
+    public Map<String, Cookie> cookieMap() {
+        if( isDebugging ) breakpoint();
+        return delegate.cookieMap();
+    }
+
+    @Override
+    public Set<Cookie> cookies(String name) {
+        if( isDebugging ) breakpoint();
+        return delegate.cookies(name);
+    }
+
+    @Override
+    public Set<Cookie> cookies() {
+        if( isDebugging ) breakpoint();
+        return delegate.cookies();
+    }
+
+    @Override
+    public HttpServerRequest routed(String route) {
+        if( isDebugging ) breakpoint();
+        return delegate.routed(route);
+    }
+
+    @Override
+    public Pipe<Buffer> pipe() {
+        if( isDebugging ) breakpoint();
+        return delegate.pipe();
+    }
+
+    @Override
+    public Future<Void> pipeTo(WriteStream<Buffer> dst) {
+        if( isDebugging ) breakpoint();
+        return delegate.pipeTo(dst);
+    }
+
+    @Override
+    public void pipeTo(WriteStream<Buffer> dst, Handler<AsyncResult<Void>> handler) {
+        if( isDebugging ) breakpoint();
+        delegate.pipeTo(dst, handler);
+    }
+
+    @Override
+    public Context context() {
+        if( isDebugging ) breakpoint();
+        return delegate.context();
+    }
+
+    @Override
+    public Object metric() {
+        if( isDebugging ) breakpoint();
+        return delegate.metric();
+    }
+
+}
diff --git a/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateVertxHttpServerResponse.java b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateVertxHttpServerResponse.java
new file mode 100644
index 0000000..a13a8e2
--- /dev/null
+++ b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/DelegateVertxHttpServerResponse.java
@@ -0,0 +1,105 @@
+package ch.hiddenalpha.unspecifiedgarbage.gateleenKludge.tmoutissue20240123;
+
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Future;
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.http.Cookie;
+import io.vertx.core.http.HttpFrame;
+import io.vertx.core.http.HttpMethod;
+import io.vertx.core.http.HttpServerResponse;
+import io.vertx.core.http.StreamPriority;
+import io.vertx.core.streams.ReadStream;
+
+import java.util.Set;
+
+public class DelegateVertxHttpServerResponse implements HttpServerResponse {
+
+    private final HttpServerResponse delegate;
+
+    public DelegateVertxHttpServerResponse(HttpServerResponse delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override public HttpServerResponse exceptionHandler(Handler<Throwable> handler) { return delegate.exceptionHandler(handler); }
+    @Override public HttpServerResponse setWriteQueueMaxSize(int maxSize) { return delegate.setWriteQueueMaxSize(maxSize); }
+    @Override public HttpServerResponse drainHandler(Handler<Void> handler) { return delegate.drainHandler(handler); }
+    @Override public int getStatusCode() { return delegate.getStatusCode(); }
+    @Override public HttpServerResponse setStatusCode(int statusCode) { return delegate.setStatusCode(statusCode); }
+    @Override public String getStatusMessage() { return delegate.getStatusMessage(); }
+    @Override public HttpServerResponse setStatusMessage(String statusMessage) { return delegate.setStatusMessage(statusMessage); }
+    @Override public HttpServerResponse setChunked(boolean chunked) { return delegate.setChunked(chunked); }
+    @Override public boolean isChunked() { return delegate.isChunked(); }
+    @Override public MultiMap headers() { return delegate.headers(); }
+    @Override public HttpServerResponse putHeader(String name, String value) { return delegate.putHeader(name, value); }
+    @Override public HttpServerResponse putHeader(CharSequence name, CharSequence value) { return delegate.putHeader(name, value); }
+    @Override public HttpServerResponse putHeader(String name, Iterable<String> values) { return delegate.putHeader(name, values); }
+    @Override public HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values) { return delegate.putHeader(name, values); }
+    @Override public MultiMap trailers() { return delegate.trailers(); }
+    @Override public HttpServerResponse putTrailer(String name, String value) { return delegate.putTrailer(name, value); }
+    @Override public HttpServerResponse putTrailer(CharSequence name, CharSequence value) { return delegate.putTrailer(name, value); }
+    @Override public HttpServerResponse putTrailer(String name, Iterable<String> values) { return delegate.putTrailer(name, values); }
+    @Override public HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value) { return delegate.putTrailer(name, value); }
+    @Override public HttpServerResponse closeHandler(Handler<Void> handler) { return delegate.closeHandler(handler); }
+    @Override public HttpServerResponse endHandler(Handler<Void> handler) { return delegate.endHandler(handler); }
+    @Override public Future<Void> write(String chunk, String enc) { return delegate.write(chunk, enc); }
+    @Override public void write(String chunk, String enc, Handler<AsyncResult<Void>> handler) { delegate.write(chunk, enc, handler); }
+    @Override public Future<Void> write(String chunk) { return delegate.write(chunk); }
+    @Override public void write(String chunk, Handler<AsyncResult<Void>> handler) { delegate.write(chunk, handler); }
+    @Override public HttpServerResponse writeContinue() { return delegate.writeContinue(); }
+    @Override public Future<Void> end(String chunk) { return delegate.end(chunk); }
+    @Override public void end(String chunk, Handler<AsyncResult<Void>> handler) { delegate.end(chunk, handler); }
+    @Override public Future<Void> end(String chunk, String enc) { return delegate.end(chunk, enc); }
+    @Override public void end(String chunk, String enc, Handler<AsyncResult<Void>> handler) { delegate.end(chunk, enc, handler); }
+    @Override public Future<Void> end(Buffer chunk) { return delegate.end(chunk); }
+    @Override public void end(Buffer chunk, Handler<AsyncResult<Void>> handler) { delegate.end(chunk, handler); }
+    @Override public Future<Void> end() { return delegate.end(); }
+    @Override public void send(Handler<AsyncResult<Void>> handler) { delegate.send(handler); }
+    @Override public Future<Void> send() { return delegate.send(); }
+    @Override public void send(String body, Handler<AsyncResult<Void>> handler) { delegate.send(body, handler); }
+    @Override public Future<Void> send(String body) { return delegate.send(body); }
+    @Override public void send(Buffer body, Handler<AsyncResult<Void>> handler) { delegate.send(body, handler); }
+    @Override public Future<Void> send(Buffer body) { return delegate.send(body); }
+    @Override public void send(ReadStream<Buffer> body, Handler<AsyncResult<Void>> handler) { delegate.send(body, handler); }
+    @Override public Future<Void> send(ReadStream<Buffer> body) { return delegate.send(body); }
+    @Override public Future<Void> sendFile(String filename) { return delegate.sendFile(filename); }
+    @Override public Future<Void> sendFile(String filename, long offset) { return delegate.sendFile(filename, offset); }
+    @Override public Future<Void> sendFile(String filename, long offset, long length) { return delegate.sendFile(filename, offset, length); }
+    @Override public HttpServerResponse sendFile(String filename, Handler<AsyncResult<Void>> resultHandler) { return delegate.sendFile(filename, resultHandler); }
+    @Override public HttpServerResponse sendFile(String filename, long offset, Handler<AsyncResult<Void>> resultHandler) { return delegate.sendFile(filename, offset, resultHandler); }
+    @Override public HttpServerResponse sendFile(String filename, long offset, long length, Handler<AsyncResult<Void>> resultHandler) { return delegate.sendFile(filename, offset, length, resultHandler); }
+    @Override public void close() { delegate.close(); }
+    @Override public boolean ended() { return delegate.ended(); }
+    @Override public boolean closed() { return delegate.closed(); }
+    @Override public boolean headWritten() { return delegate.headWritten(); }
+    @Override public HttpServerResponse headersEndHandler(Handler<Void> handler) { return delegate.headersEndHandler(handler); }
+    @Override public HttpServerResponse bodyEndHandler(Handler<Void> handler) { return delegate.bodyEndHandler(handler); }
+    @Override public long bytesWritten() { return delegate.bytesWritten(); }
+    @Override public int streamId() { return delegate.streamId(); }
+    @Override public HttpServerResponse push(HttpMethod method, String host, String path, Handler<AsyncResult<HttpServerResponse>> handler) { return delegate.push(method, host, path, handler); }
+    @Override public Future<HttpServerResponse> push(HttpMethod method, String host, String path) { return delegate.push(method, host, path); }
+    @Override public HttpServerResponse push(HttpMethod method, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler) { return delegate.push(method, path, headers, handler); }
+    @Override public Future<HttpServerResponse> push(HttpMethod method, String path, MultiMap headers) { return delegate.push(method, path, headers); }
+    @Override public HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler) { return delegate.push(method, path, handler); }
+    @Override public Future<HttpServerResponse> push(HttpMethod method, String path) { return delegate.push(method, path); }
+    @Override public HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler) { return delegate.push(method, host, path, headers, handler); }
+    @Override public Future<HttpServerResponse> push(HttpMethod method, String host, String path, MultiMap headers) { return delegate.push(method, host, path, headers); }
+    @Override public boolean reset() { return delegate.reset(); }
+    @Override public boolean reset(long code) { return delegate.reset(code); }
+    @Override public HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload) { return delegate.writeCustomFrame(type, flags, payload); }
+    @Override public HttpServerResponse writeCustomFrame(HttpFrame frame) { return delegate.writeCustomFrame(frame); }
+    @Override public HttpServerResponse setStreamPriority(StreamPriority streamPriority) { return delegate.setStreamPriority(streamPriority); }
+    @Override public HttpServerResponse addCookie(Cookie cookie) { return delegate.addCookie(cookie); }
+    @Override public Cookie removeCookie(String name) { return delegate.removeCookie(name); }
+    @Override public Cookie removeCookie(String name, boolean invalidate) { return delegate.removeCookie(name, invalidate); }
+    @Override public Set<Cookie> removeCookies(String name) { return delegate.removeCookies(name); }
+    @Override public Set<Cookie> removeCookies(String name, boolean invalidate) { return delegate.removeCookies(name, invalidate); }
+    @Override public Cookie removeCookie(String name, String domain, String path) { return delegate.removeCookie(name, domain, path); }
+    @Override public Cookie removeCookie(String name, String domain, String path, boolean invalidate) { return delegate.removeCookie(name, domain, path, invalidate); }
+    @Override public Future<Void> write(Buffer data) { return delegate.write(data); }
+    @Override public void write(Buffer data, Handler<AsyncResult<Void>> handler) { delegate.write(data, handler); }
+    @Override public void end(Handler<AsyncResult<Void>> handler) { delegate.end(handler); }
+    @Override public boolean writeQueueFull() { return delegate.writeQueueFull(); }
+
+}
diff --git a/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/Foo.java b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/Foo.java
new file mode 100644
index 0000000..4eb1e20
--- /dev/null
+++ b/src/main/java/ch/hiddenalpha/unspecifiedgarbage/gateleenKludge/tmoutissue20240123/Foo.java
@@ -0,0 +1,129 @@
+package ch.hiddenalpha.unspecifiedgarbage.gateleenKludge.tmoutissue20240123;
+
+import io.vertx.core.http.HttpServerRequest;
+import io.vertx.ext.web.RoutingContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class Foo {
+
+    private static final Logger log = Foo.getLogger(Foo.class);
+    private static final boolean assertRequestEquality = true;
+    private static HttpServerRequest serverInfoRequest;
+    private static io.vertx.core.http.impl.HttpServerRequestInternal restStorageEvBusAdaptMappdHttpServReq;
+    private static long onBeginRouteEpochMs;
+
+    public static synchronized void onNewServerInfoRequst(HttpServerRequest request){
+        if( !isServerInfoRequst(request) ) return;
+        //assert serverInfoRequest == null;
+        log.trace("onNewServerInfoRequst()");
+        serverInfoRequest = request;
+    }
+
+    public static void downReqBegin(HttpServerRequest req) {
+        if( !isServerInfoRequst(req) ) return;
+        log.trace("downReqBegin()");
+        assert !assertRequestEquality || serverInfoRequest == req;
+    }
+
+    public static void downReqAuthorized(HttpServerRequest req) {
+        if( !isServerInfoRequst(req) ) return;
+        log.trace("downReqAuthorized()");
+        assert !assertRequestEquality || serverInfoRequest == req;
+    }
+
+    public static void onBeforeMainVerticleRouteGeneric(HttpServerRequest req) {
+        if( !isServerInfoRequst(req) ) return;
+        log.trace("onBeforeMainVerticleRouteGeneric()");
+        onBeginRouteEpochMs = System.currentTimeMillis();
+        assert !assertRequestEquality || serverInfoRequest == req;
+    }
+
+    public static Logger getLogger(Class<?> clazz) {
+        assert clazz != null;
+        return getLogger(clazz.getName());
+    }
+
+    public static Logger getLogger(String name) {
+        assert name != null;
+        return LoggerFactory.getLogger("FOO."+ name);
+    }
+
+    public static boolean isServerInfoRequst(HttpServerRequest request) {
+        return isServerInfoRequst(request.uri());
+    }
+
+    private static boolean isServerInfoRequst(String uri) {
+        assert uri != null;
+        assert uri.startsWith("/");
+        try{
+            if( "/houston/server/info".equals(uri) ){
+                //log.trace("true <- isServerInfoRequst({})", uri);
+                return true;
+            }
+            //log.trace("false <- isServerInfoRequst({})", uri);
+            return false;
+        }catch(Throwable ex){
+            assert false;
+            throw ex;
+        }
+    }
+
+    public static void onBeforeEvBusAdapterDataHandler(String uri) {
+        if( !isServerInfoRequst(uri) ) return;
+        log.trace("onBeforeEvBusAdapterDataHandler({})", uri);
+        assert false;
+    }
+
+    public static void onBeforeEvBusAdapterEndHandler(String uri) {
+        if( !isServerInfoRequst(uri)) return;
+        log.trace("onBeforeEvBusAdapterEndHandler({})", uri);
+        assert false;
+    }
+
+    public static void onEvBusAdapterHandle(io.vertx.core.http.impl.HttpServerRequestInternal req) {
+        if( !isServerInfoRequst(req.uri()) ) return;
+        assert !assertRequestEquality || serverInfoRequest != req;
+        assert restStorageEvBusAdaptMappdHttpServReq == null;
+        log.trace("onEvBusAdapterHandle({})", req.uri());
+        restStorageEvBusAdaptMappdHttpServReq = req;
+    }
+
+    public static void onEvBusAdapterError(Throwable ex) {
+        log.error("onEvBusAdapterError()", new Exception("stacktrace", ex));
+    }
+
+    public static void onRestStorageHandlerHandle(HttpServerRequest req) {
+        if( !isServerInfoRequst(req) ) return;
+        log.trace("onRestStorageHandlerHandle({})", req.uri());
+        assert !assertRequestEquality || serverInfoRequest == req;
+    }
+
+    public static void onRestStorageHandler_getResource(io.vertx.ext.web.RoutingContext ctx) {
+        if( !isServerInfoRequst(ctx.request()) ) return;
+        assert !assertRequestEquality || serverInfoRequest == ctx.request();
+        log.trace("onRestStorageHandler_getResource({})", ctx.request().uri());
+    }
+
+    public static void onRestStorageHandler_getResource_before_storage_get(String path, int offset, int limit) {
+        //log.trace("onRestStorageHandler_getResource_before_storage_get({}, {}, {})", path, offset, limit);
+    }
+
+    public static void onRestStorageHandler_getResource_after_storage_get(String path, int offset, int limit, Object/*org.swisspush.reststorage.Resource*/ resource) {
+        //log.trace("onRestStorageHandler_getResource_after_storage_get({})", path);
+    }
+
+    public static void onGetHoustonServerInfo(RoutingContext ctx) {
+        var req = ctx.request();
+        log.trace("onGetHoustonServerInfo({})", req.uri());
+        assert !assertRequestEquality || serverInfoRequest != req;
+    }
+
+    public static void onEndCompleted(long responseBegEpochMs){
+        long durationMs = System.currentTimeMillis() - responseBegEpochMs;
+        log.debug("Request took {}ms", durationMs);
+    }
+
+}
+