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

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

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

Making http requests using okhttp
getSystemService (Context)
compareTo (BigDecimal)
Compares this BigDecimal with the specified BigDecimal. Two BigDecimal objects that are equal in val
getApplicationContext (Context)
ByteBuffer (java.nio)
A buffer for bytes. A byte buffer can be created in either one of the following ways: * #allocate(i
Date (java.sql)
A class which can consume and produce dates in SQL Date format. Dates are represented in SQL as yyyy
Iterator (java.util)
An iterator over a collection. Iterator takes the place of Enumeration in the Java Collections Frame
BlockingQueue (java.util.concurrent)
A java.util.Queue that additionally supports operations that wait for the queue to become non-empty
Executors (java.util.concurrent)
Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory,
FileUtils (org.apache.commons.io)
General file manipulation utilities. Facilities are provided in the following areas: * writing to a

How to use netSocketmethodin io.vertx.core.http.HttpClientResponse

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

How to use
netSocket
method
in
io.vertx.core.http.HttpClientResponse