Added path/query on HttpClientRequest so it's easier to get these fro…

…m pushed requests

src/main/java/io/vertx/core/http/HttpClientRequest.java

@@ -110,6 +110,16 @@ public interface HttpClientRequest extends WriteStream<Buffer>, ReadStream<HttpC
    */
   String uri();
 
+  /**
+   * @return The path part of the uri. For example /somepath/somemorepath/someresource.foo
+   */
+  String path();
+
+  /**
+   * @return the query part of the uri. For example someparam=32&amp;someotherparam=x
+   */
+  String query();
+
   /**
    * Set the request host.<p/>
    *

src/main/java/io/vertx/core/http/impl/ClientConnection.java

@@ -345,7 +345,7 @@ void handleResponseEnd(LastHttpContent trailer) {
 
     // We don't signal response end for a 100-continue response as a real response will follow
     // Also we keep the connection open for an HTTP CONNECT
-    if (currentResponse.statusCode() != 100 && requestForResponse.getMethod() != io.vertx.core.http.HttpMethod.CONNECT) {
+    if (currentResponse.statusCode() != 100 && requestForResponse.method() != io.vertx.core.http.HttpMethod.CONNECT) {
 
       boolean close = false;
       // See https://tools.ietf.org/html/rfc7230#section-6.3

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

@@ -31,14 +31,24 @@ abstract class HttpClientRequestBase implements HttpClientRequest {
   private static final Logger log = LoggerFactory.getLogger(HttpClientRequestImpl.class);
 
   protected final HttpClientImpl client;
+  protected final io.vertx.core.http.HttpMethod method;
+  protected final String uri;
+  protected final String path;
+  protected final String host;
+  protected final String query;
   private Handler<Throwable> exceptionHandler;
   private long currentTimeoutTimerId = -1;
   private long lastDataReceived;
   protected boolean exceptionOccurred;
   private Object metric;
 
-  HttpClientRequestBase(HttpClientImpl client) {
+  HttpClientRequestBase(HttpClientImpl client, io.vertx.core.http.HttpMethod method, String host, String uri) {
     this.client = client;
+    this.uri = uri;
+    this.method = method;
+    this.host = host;
+    this.path = HttpUtils.parsePath(uri);
+    this.query = HttpUtils.parseQuery(uri);
   }
 
   Object metric() {
@@ -53,6 +63,23 @@ void metric(Object metric) {
   protected abstract void doHandleResponse(HttpClientResponseImpl resp);
   protected abstract void checkComplete();
 
+  public String query() {
+    return query;
+  }
+
+  public String path() {
+    return path;
+  }
+
+  public String uri() {
+    return uri;
+  }
+
+  @Override
+  public io.vertx.core.http.HttpMethod method() {
+    return method;
+  }
+
   @Override
   public HttpClientRequest exceptionHandler(Handler<Throwable> handler) {
     synchronized (getLock()) {

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

@@ -48,13 +48,9 @@
  */
 public class HttpClientRequestImpl extends HttpClientRequestBase implements HttpClientRequest {
 
-  private final String host;
-  private final int port;
   private final boolean ssl;
-  private final HttpClientImpl client;
   private final VertxInternal vertx;
-  private final io.vertx.core.http.HttpMethod method;
-  private final String uri;
+  private final int port;
   private Handler<HttpClientResponse> respHandler;
   private Handler<Void> endHandler;
   private boolean chunked;
@@ -76,15 +72,11 @@ public class HttpClientRequestImpl extends HttpClientRequestBase implements Http
 
   HttpClientRequestImpl(HttpClientImpl client, io.vertx.core.http.HttpMethod method, String host, int port,
                         boolean ssl, String relativeURI, VertxInternal vertx) {
-    super(client);
-    this.host = host;
-    this.port = port;
-    this.client = client;
+    super(client, method, host, relativeURI);
     this.chunked = false;
-    this.method = method;
     this.vertx = vertx;
-    this.uri = relativeURI;
     this.ssl = ssl;
+    this.port = port;
   }
 
   @Override
@@ -158,16 +150,6 @@ public String getHost() {
     }
   }
 
-  @Override
-  public io.vertx.core.http.HttpMethod method() {
-    return method;
-  }
-
-  @Override
-  public String uri() {
-    return uri;
-  }
-
   @Override
   public MultiMap headers() {
     synchronized (getLock()) {
@@ -421,10 +403,6 @@ protected void doHandleResponse(HttpClientResponseImpl resp) {
     }
   }
 
-  io.vertx.core.http.HttpMethod getMethod() {
-    return method;
-  }
-
   // After connecting we should synchronize on the client connection instance to prevent deadlock conditions
   // but there is a catch - the client connection is null before connecting so we synchronized on this before that
   // point

src/main/java/io/vertx/core/http/impl/HttpClientRequestPushPromise.java

@@ -49,7 +49,7 @@ public HttpClientRequestPushPromise(
       String uri,
       String host,
       MultiMap headers) throws Http2Exception {
-    super(client);
+    super(client, method, host, uri);
     this.handler = handler;
     this.clientStream = new Http2ClientConnection.Http2ClientStream(handler, this, clientStream);
     this.method = method;

src/test/java/io/vertx/test/core/Http2ClientTest.java

@@ -629,7 +629,7 @@ public void testClientResetServerStream() throws Exception {
   public void testPushPromise() throws Exception {
     waitFor(2);
     server.requestHandler(req -> {
-      req.response().push(HttpMethod.GET, "/wibble", ar -> {
+      req.response().push(HttpMethod.GET, "/wibble?a=b", ar -> {
         assertTrue(ar.succeeded());
         HttpServerResponse response = ar.result();
         response.end("the_content");
@@ -657,7 +657,9 @@ public void testPushPromise() throws Exception {
       }
       assertOnIOContext(current);
       assertEquals(HttpMethod.GET, pushedReq.method());
-      assertEquals("/wibble", pushedReq.uri());
+      assertEquals("/wibble?a=b", pushedReq.uri());
+      assertEquals("/wibble", pushedReq.path());
+      assertEquals("a=b", pushedReq.query());
       pushedReq.handler(resp -> {
         assertEquals(200, resp.statusCode());
         Buffer content = Buffer.buffer();