How to use

netSocket

method

in

io.vertx.core.http.HttpClientResponse

@Test
public void testClientNetSocketCloseRemovesFromThePool() throws Exception {
 testHttpClientResponseThrowsExceptionInHandler(null, (resp, latch) -> {
  NetSocket socket = resp.netSocket();
  socket.closeHandler(v -> {
   latch.countDown();
  });
  socket.close();
 });
}

client.request(HttpMethod.CONNECT, DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> {
 assertEquals(200, resp.statusCode());
 NetSocket socket = resp.netSocket();
 StringBuilder received = new StringBuilder();
 AtomicInteger count = new AtomicInteger();

HttpClient client = vertx.createHttpClient();
client.put(8080, "localhost", "/", onSuccess(resp -> {
 resp.netSocket().closeHandler(v -> {
  vertx.close(v4 -> {
   assertTrue(requestBeginCalled.get());

clientMetric.set(metrics.getMetric(request));
assertNotNull(clientMetric.get());
NetSocket socket = resp.netSocket();
socket.write(Buffer.buffer("hello"));
socket.handler(buf -> {

client.request(HttpMethod.CONNECT, DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> {
 assertEquals(200, resp.statusCode());
 NetSocket socket = resp.netSocket();
 AtomicInteger count = new AtomicInteger();
 socket.handler(buff -> {

private void handshake(Handler<NetSocket> handler) {
 HttpClientRequest request = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/",
  onSuccess(resp -> {
   assertEquals(101, resp.statusCode());
   handler.handle(resp.netSocket());
  })
 );
 request
  .putHeader("Upgrade", "websocket")
  .putHeader("Connection", "Upgrade")
  .putHeader("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==")
  .putHeader("Sec-WebSocket-Protocol", "chat")
  .putHeader("Sec-WebSocket-Version", "13")
  .putHeader("Origin", "http://example.com");
 request.end();
}

@Test
public void testAccessNetSocket() throws Exception {
 Buffer toSend = TestUtils.randomBuffer(1000);
 server.requestHandler(req -> {
  req.response().headers().set("HTTP/1.1", "101 Upgrade");
  req.bodyHandler(data -> {
   assertEquals(toSend, data);
   req.response().end("somecontent");
  });
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertNotNull(resp.netSocket());
    testComplete();
   });
  }));
  req.headers().set("content-length", String.valueOf(toSend.length()));
  req.write(toSend);
 }));
 await();
}

private void testAccessNetSocketPendingResponseData(boolean pause) {
 server.requestHandler(req -> {
  NetSocket so = req.netSocket();
  so.write("hello");
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = client.request(HttpMethod.CONNECT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   NetSocket so = resp.netSocket();
   assertNotNull(so);
   so.handler(buff -> {
    // With HTTP/1.1 the buffer is received immediately but delivered asynchronously
    assertEquals("hello", buff.toString());
    testComplete();
   });
   if (pause) {
    so.pause();
    vertx.setTimer(100, id -> {
     so.resume();
    });
   }
  }));
  req.sendHead();
 }));
 await();
}

client.request(HttpMethod.CONNECT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
 assertEquals(200, resp.statusCode());
 NetSocket socket = resp.netSocket();
 socket.handler(buff -> {
  received.appendBuffer(buff);

protected void handleResponse(HttpClientResponse httpClientResponse) {
 this.clientResponse = httpClientResponse;
 if (HttpStatus.isSuccess(clientResponse.statusCode())
   && Part.class.equals(invocation.getOperationMeta().getMethod().getReturnType())) {
  ReadStreamPart part = new ReadStreamPart(httpClientWithContext.context(), httpClientResponse);
  invocation.getHandlerContext().put(RestConst.READ_STREAM_PART, part);
  processResponseBody(null);
  return;
 }
 httpClientResponse.exceptionHandler(e -> {
  LOGGER.error("Failed to receive response from {}.", httpClientResponse.netSocket().remoteAddress(), e);
  fail(e);
 });
 clientResponse.bodyHandler(responseBuf -> {
  processResponseBody(responseBuf);
 });
}

@Test
public void testClientNetSocketCloseRemovesFromThePool() throws Exception {
 testHttpClientResponseThrowsExceptionInHandler(null, (resp, latch) -> {
  NetSocket socket = resp.netSocket();
  socket.closeHandler(v -> {
   latch.countDown();
  });
  socket.close();
 });
}

client.request(HttpMethod.CONNECT, DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", resp -> {
 assertEquals(200, resp.statusCode());
 NetSocket socket = resp.netSocket();
 StringBuilder received = new StringBuilder();
 AtomicInteger count = new AtomicInteger();

HttpClient client = vertx.createHttpClient();
client.put(8080, "localhost", "/", resp -> {
 resp.netSocket().closeHandler(v -> {
  vertx.close(v4 -> {
   assertTrue(requestBeginCalled.get());

private void handshake(HttpClientRequest request, Handler<NetSocket> handler) {
 request
  .putHeader("Upgrade", "websocket")
  .putHeader("Connection", "Upgrade")
  .putHeader("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==")
  .putHeader("Sec-WebSocket-Protocol", "chat")
  .putHeader("Sec-WebSocket-Version", "13")
  .putHeader("Origin", "http://example.com");
 request.handler(resp -> {
  assertEquals(101, resp.statusCode());
  handler.handle(resp.netSocket());
 });
 request.end();
}

clientMetric.set(metrics.getMetric(request));
assertNotNull(clientMetric.get());
NetSocket socket = resp.netSocket();
socket.write(Buffer.buffer("hello"));
socket.handler(buf -> {

@Test
public void testAccessNetSocket() throws Exception {
 Buffer toSend = TestUtils.randomBuffer(1000);
 server.requestHandler(req -> {
  req.response().headers().set("HTTP/1.1", "101 Upgrade");
  req.bodyHandler(data -> {
   assertEquals(toSend, data);
   req.response().end("somecontent");
  });
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
   resp.endHandler(v -> {
    assertNotNull(resp.netSocket());
    testComplete();
   });
  });
  req.headers().set("content-length", String.valueOf(toSend.length()));
  req.write(toSend);
 }));
 await();
}

client.request(HttpMethod.CONNECT, DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", resp -> {
 assertEquals(200, resp.statusCode());
 NetSocket socket = resp.netSocket();
 AtomicInteger count = new AtomicInteger();
 socket.handler(buff -> {

private void testAccessNetSocketPendingResponseData(boolean pause) {
 server.requestHandler(req -> {
  NetSocket so = req.netSocket();
  so.write("hello");
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = client.request(HttpMethod.CONNECT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
   NetSocket so = resp.netSocket();
   assertNotNull(so);
   so.handler(buff -> {
    // With HTTP/1.1 the buffer is received immediately but delivered asynchronously
    assertEquals("hello", buff.toString());
    testComplete();
   });
   if (pause) {
    so.pause();
    vertx.setTimer(100, id -> {
     so.resume();
    });
   }
  });
  req.sendHead();
 }));
 await();
}

client.request(HttpMethod.CONNECT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> {
 assertEquals(200, resp.statusCode());
 NetSocket socket = resp.netSocket();
 socket.handler(buff -> {
  received.appendBuffer(buff);

@Override
public void abort(Throwable t) {
  bodyHandler(null);
  if(clientRequest != null) {
    clientRequest.end();
  }
  if(clientResponse != null) {
    clientResponse.netSocket().close(); //TODO verify
  }
}