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

@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
notifyDataSetChanged (ArrayAdapter)
findViewById (Activity)
setContentView (Activity)
Calendar (java.util)
Calendar is an abstract base class for converting between a Date object and a set of integer fields
TimerTask (java.util)
The TimerTask class represents a task to run at a specified time. The task may be run once or repeat
Modifier (javassist)
The Modifier class provides static methods and constants to decode class and member access modifiers
JOptionPane (javax.swing)
JPanel (javax.swing)
Runner (org.openjdk.jmh.runner)
Top 17 Plugins for Android Studio

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