Introduce HttpServerStream internal API akin HttpClientStream and decouple Http2ServerRequest/Http2ServerResponse from Http2Stream* API to use instead HttpStream internal API.

Author: vietj

vertx-core/src/main/java/io/vertx/core/http/impl/Http1xClientConnection.java

@@ -501,7 +501,7 @@ public boolean isWritable() {
     }
 
     @Override
-    public HttpClientStream headersHandler(Handler<HttpResponseHead> handler) {
+    public HttpClientStream headHandler(Handler<HttpResponseHead> handler) {
       this.headHandler = handler;
       return this;
     }
@@ -573,7 +573,7 @@ public Future<Void> writeHead(HttpRequestHead request, boolean chunked, Buffer b
     }
 
     @Override
-    public Future<Void> write(Buffer buff, boolean end) {
+    public Future<Void> writeChunk(Buffer buff, boolean end) {
       if (buff != null || end) {
         Promise<Void> listener = context.promise();
         conn.writeBuffer(this, buff != null ? ((BufferInternal)buff).getByteBuf() : null, end, listener);

vertx-core/src/main/java/io/vertx/core/http/impl/Http1xServerConnection.java

@@ -28,6 +28,7 @@
 import io.vertx.core.*;
 import io.vertx.core.buffer.Buffer;
 import io.vertx.core.http.ServerWebSocketHandshake;
+import io.vertx.core.http.impl.headers.HeadersMultiMap;
 import io.vertx.core.internal.buffer.BufferInternal;
 import io.vertx.core.http.HttpServerOptions;
 import io.vertx.core.http.HttpServerRequest;
@@ -114,6 +115,16 @@ protected void handleShutdown(ChannelPromise promise) {
     }
   }
 
+  @Override
+  public MultiMap newHeaders() {
+    return io.vertx.core.http.HttpHeaders.headers();
+  }
+
+  @Override
+  public boolean supportsSendFile() {
+    return true;
+  }
+
   TracingPolicy tracingPolicy() {
     return tracingPolicy;
   }

vertx-core/src/main/java/io/vertx/core/http/impl/Http2UpgradeClientConnection.java

@@ -151,8 +151,8 @@ public Future<Void> writeHead(HttpRequestHead request, boolean chunked, Buffer b
     }
 
     @Override
-    public Future<Void> write(Buffer buf, boolean end) {
-      return delegate.write(buf, end);
+    public Future<Void> writeChunk(Buffer buf, boolean end) {
+      return delegate.writeChunk(buf, end);
     }
 
     @Override
@@ -185,8 +185,8 @@ public HttpClientStream customFrameHandler(Handler<HttpFrame> handler) {
     }
 
     @Override
-    public HttpClientStream headersHandler(Handler<HttpResponseHead> handler) {
-      delegate.headersHandler(handler);
+    public HttpClientStream headHandler(Handler<HttpResponseHead> handler) {
+      delegate.headHandler(handler);
       return this;
     }
 
@@ -280,7 +280,7 @@ private static class UpgradingStream implements HttpClientStream {
 
     void handleUpgrade(HttpClientConnection conn, HttpClientStream stream) {
       upgradedStream = stream;
-      upgradedStream.headersHandler(headHandler);
+      upgradedStream.headHandler(headHandler);
       upgradedStream.dataHandler(chunkHandler);
       upgradedStream.trailersHandler(trailersHandler);
       upgradedStream.priorityChangeHandler(priorityHandler);
@@ -292,7 +292,7 @@ void handleUpgrade(HttpClientConnection conn, HttpClientStream stream) {
       upgradedStream.pushHandler(pushHandler);
       upgradedStream.customFrameHandler(unknownFrameHandler);
       upgradedStream.closeHandler(closeHandler);
-      upgradingStream.headersHandler(null);
+      upgradingStream.headHandler(null);
       upgradingStream.dataHandler(null);
       upgradingStream.trailersHandler(null);
       upgradingStream.priorityChangeHandler(null);
@@ -531,11 +531,11 @@ public UpgradingStream exceptionHandler(Handler<Throwable> handler) {
     }
 
     @Override
-    public HttpClientStream headersHandler(Handler<HttpResponseHead> handler) {
+    public HttpClientStream headHandler(Handler<HttpResponseHead> handler) {
       if (upgradedStream != null) {
-        upgradedStream.headersHandler(handler);
+        upgradedStream.headHandler(handler);
       } else {
-        upgradingStream.headersHandler(handler);
+        upgradingStream.headHandler(handler);
         headHandler = handler;
       }
       return this;
@@ -605,10 +605,10 @@ public boolean isWritable() {
     }
 
     @Override
-    public Future<Void> write(Buffer buf, boolean end) {
+    public Future<Void> writeChunk(Buffer buf, boolean end) {
       EventExecutor exec = upgradingConnection.channelHandlerContext().executor();
       if (exec.inEventLoop()) {
-        Future<Void> future = upgradingStream.write(buf, end);
+        Future<Void> future = upgradingStream.writeChunk(buf, end);
         if (end) {
           ChannelPipeline pipeline = upgradingConnection.channelHandlerContext().pipeline();
           future = future.andThen(ar -> {
@@ -621,7 +621,7 @@ public Future<Void> write(Buffer buf, boolean end) {
       } else {
         Promise<Void> promise = upgradingStream.context().promise();
         exec.execute(() -> {
-          Future<Void> future = write(buf, end);
+          Future<Void> future = writeChunk(buf, end);
           future.onComplete(promise);
         });
         return promise.future();

vertx-core/src/main/java/io/vertx/core/http/impl/HttpChannelConnector.java

@@ -259,7 +259,7 @@ private void http1xConnected(HttpVersion version,
           conn2.createStream(conn.context()).onComplete(ar -> {
             if (ar.succeeded()) {
               HttpClientStream stream = ar.result();
-              stream.headersHandler(resp -> {
+              stream.headHandler(resp -> {
                 Http2UpgradeClientConnection connection = (Http2UpgradeClientConnection) stream.connection();
                 HttpClientConnection unwrap = connection.unwrap();
                 future.tryComplete(unwrap);

vertx-core/src/main/java/io/vertx/core/http/impl/HttpClientRequestBase.java

@@ -57,7 +57,7 @@ public abstract class HttpClientRequestBase implements HttpClientRequest {
 
     //
     stream.pushHandler(this::handlePush);
-    stream.headersHandler(resp -> {
+    stream.headHandler(resp -> {
       HttpClientResponseImpl response = new HttpClientResponseImpl(this, stream.version(), stream, resp.statusCode, resp.statusMessage, resp.headers);
       stream.dataHandler(response::handleChunk);
       stream.trailersHandler(response::handleTrailers);

vertx-core/src/main/java/io/vertx/core/http/impl/HttpClientRequestImpl.java

@@ -11,7 +11,6 @@
 
 package io.vertx.core.http.impl;
 
-import io.netty.buffer.ByteBuf;
 import io.netty.handler.codec.http.HttpHeaderNames;
 import io.netty.handler.codec.http.multipart.HttpPostRequestEncoder;
 import io.vertx.codegen.annotations.Nullable;
@@ -543,7 +542,7 @@ private Future<Void> doWrite(Buffer buff, boolean end, boolean connect) {
       if (buff == null && !end) {
         throw new IllegalArgumentException();
       }
-      future = stream.write(buff, writeEnd);
+      future = stream.writeChunk(buff, writeEnd);
     }
     if (end) {
       tryComplete();

vertx-core/src/main/java/io/vertx/core/http/impl/HttpClientResponseImpl.java

@@ -87,15 +87,15 @@ public WriteStream<Buffer> exceptionHandler(@Nullable Handler<Throwable> handler
         }
         @Override
         public Future<Void> write(Buffer data) {
-          return stream.write(data, false);
+          return stream.writeChunk(data, false);
         }
         @Override
         public Future<Void> end(Buffer data) {
-          return stream.write(data, true);
+          return stream.writeChunk(data, true);
         }
         @Override
         public Future<Void> end() {
-          return stream.write(BufferInternal.buffer(Unpooled.EMPTY_BUFFER), true);
+          return stream.writeChunk(BufferInternal.buffer(Unpooled.EMPTY_BUFFER), true);
         }
         @Override
         public WriteStream<Buffer> setWriteQueueMaxSize(int maxSize) {

vertx-core/src/main/java/io/vertx/core/http/impl/HttpClientStream.java

@@ -17,56 +17,35 @@
 import io.vertx.core.buffer.Buffer;
 import io.vertx.core.http.impl.http2.Http2ClientPush;
 import io.vertx.core.http.*;
-import io.vertx.core.internal.ContextInternal;
 
 /**
  * @author <a href="mailto:[email protected]">Julien Viet</a>
  */
-public interface HttpClientStream {
-
-  /**
-   * @return the stream id, {@code 1} denotes the first stream, HTTP/1 is a simple sequence, HTTP/2
-   * is the actual stream identifier.
-   */
-  int id();
-
-  Object metric();
+public interface HttpClientStream extends HttpStream {
 
   Object trace();
 
-  /**
-   * @return the stream version or null if it's not yet determined
-   */
-  HttpVersion version();
-
   HttpClientConnection connection();
-  ContextInternal context();
 
   Future<Void> writeHead(HttpRequestHead request, boolean chunked, Buffer buf, boolean end, StreamPriority priority, boolean connect);
-  Future<Void> write(Buffer buf, boolean end);
-  Future<Void> writeFrame(int type, int flags, Buffer payload);
-  Future<Void> writeReset(long code);
 
+  HttpClientStream headHandler(Handler<HttpResponseHead> handler);
   HttpClientStream resetHandler(Handler<Long> handler);
   HttpClientStream exceptionHandler(Handler<Throwable> handler);
   HttpClientStream continueHandler(Handler<Void> handler);
   HttpClientStream earlyHintsHandler(Handler<MultiMap> handler);
   HttpClientStream pushHandler(Handler<Http2ClientPush> handler);
   HttpClientStream customFrameHandler(Handler<HttpFrame> handler);
-  HttpClientStream headersHandler(Handler<HttpResponseHead> handler);
   HttpClientStream dataHandler(Handler<Buffer> handler);
   HttpClientStream trailersHandler(Handler<MultiMap> handler);
   HttpClientStream priorityChangeHandler(Handler<StreamPriority> handler);
   HttpClientStream closeHandler(Handler<Void> handler);
   HttpClientStream drainHandler(Handler<Void> handler);
 
   HttpClientStream setWriteQueueMaxSize(int maxSize);
-  boolean isWritable();
-
   HttpClientStream pause();
   HttpClientStream fetch(long amount);
 
-  StreamPriority priority();
   HttpClientStream updatePriority(StreamPriority streamPriority);
 
 }

vertx-core/src/main/java/io/vertx/core/http/impl/HttpRequestHead.java

@@ -21,6 +21,7 @@
  */
 public class HttpRequestHead implements HttpRequest {
 
+  public String scheme;
   public SocketAddress remoteAddress;
   public final HttpMethod method;
   public final String uri;

vertx-core/src/main/java/io/vertx/core/http/impl/HttpServerConnection.java

@@ -12,15 +12,21 @@
 
 import io.netty.channel.ChannelHandlerContext;
 import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
 import io.vertx.core.http.HttpConnection;
 import io.vertx.core.http.HttpServerRequest;
+import io.vertx.core.http.impl.http2.Http2HeadersMultiMap;
 import io.vertx.core.internal.ContextInternal;
 
 /**
  * @author <a href="mailto:[email protected]">Julien Viet</a>
  */
 public interface HttpServerConnection extends HttpConnection {
 
+  MultiMap newHeaders();
+
+  boolean supportsSendFile();
+
   /**
    * @return the connection context
    */