io.vertx.core.http.HttpClientResponse.netSocket java code examples

Common ways to obtain HttpClientResponse

private void myMethod () {
     HttpClientResponse h =HttpClientResponse httpClientResponse;httpClientResponse.resume()
HttpClientResponse httpClientResponse;httpClientResponse.pause()
Smart code suggestions by Codota
}

@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 -> {

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();
}

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 -> {

@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
  }
}

Javadoc

Get a net socket for the underlying connection of this request.

USE THIS WITH CAUTION! Writing to the socket directly if you don't know what you're doing can easily break the HTTP protocol.

HTTP/1.1 pipe-lined requests cannot support net socket upgrade.

One valid use-case for calling this is to receive the io.vertx.core.net.NetSocket after a HTTP CONNECT was issued to the remote peer and it responded with a status code of 200.

Popular methods of HttpClientResponse

statusCode
bodyHandler
Convenience method for receiving the entire request body in one piece. This saves you having to manu
statusMessage
headers
exceptionHandler
endHandler
getHeader
Return the first header value with the specified name
handler
pause
resume
request
cookies

Popular in Java

Start an intent from android
setRequestProperty (URLConnection)
onRequestPermissionsResult (Fragment)
putExtra (Intent)
InputStreamReader (java.io)
A class for turning a byte stream into a character stream. Data read from the source input stream is
System (java.lang)
Provides access to system-related information and resources including standard input and output. Ena
Calendar (java.util)
Calendar is an abstract base class for converting between a Date object and a set of integer fields
Handler (java.util.logging)
A Handler object accepts a logging request and exports the desired messages to a target, for example
Runner (org.openjdk.jmh.runner)
LoggerFactory (org.slf4j)
The LoggerFactory is a utility class producing Loggers for various logging APIs, most notably for lo

Best Java code snippets using io.vertx.core.http.HttpClientResponse.netSocket (Showing top 20 results out of 315)