io.vertx.core.http.HttpClientResponse.endHandler 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 testHttpClientResponseThrowsExceptionInEndHandler() throws Exception {
 testHttpClientResponseThrowsExceptionInHandler(null, (resp, latch) -> {
  resp.endHandler(v -> {
   latch.countDown();
   throw new RuntimeException();
  });
 });
}

@Test
public void testHttpClientResponsePauseIsIgnoredAtRequestEnd() throws Exception {
 testHttpClientResponsePause(resp -> {
  resp.endHandler(v -> {
   // Pausing the request in end handler should be a no-op
   resp.pause();
  });
 });
}

@Test
public void testDefaultHttpVersion() {
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_1, req.version());
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> resp.endHandler(v -> testComplete()))).end();
 }));
 await();
}

@Test
public void testGetAbsoluteURI() {
 server.requestHandler(req -> {
  assertEquals(req.scheme() + "://localhost:" + DEFAULT_HTTP_PORT + "/foo/bar", req.absoluteURI());
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/foo/bar", onSuccess(resp -> resp.endHandler(v -> testComplete()))).end();
 }));
 await();
}

@Test
public void testRemoteAddress() {
 server.requestHandler(req -> {
  assertEquals("127.0.0.1", req.remoteAddress().host());
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> resp.endHandler(v -> testComplete()))).end();
 }));
 await();
}

 @Test
 public void testNoRequestHandler() throws Exception {
  CountDownLatch latch = new CountDownLatch(1);
  vertx.createHttpServer()
   .websocketHandler(ws -> fail())
   .listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v -> latch.countDown()));
  awaitLatch(latch);
  client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> {
   resp.endHandler(v -> {
    assertEquals(400, resp.statusCode());
    testComplete();
   });
  }));
  await();
 }
}

@Test
public void testSendHeadersCompletionHandler() throws Exception {
 AtomicInteger status = new AtomicInteger();
 server.requestHandler(req -> {
  req.response().end();
 });
 startServer();
 HttpClientRequest req = client.request(HttpMethod.CONNECT, DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> {
  assertEquals(1, status.getAndIncrement());
  resp.endHandler(v -> {
   assertEquals(2, status.getAndIncrement());
   testComplete();
  });
 }));
 req.sendHead(version -> {
  assertEquals(0, status.getAndIncrement());
  assertSame(HttpVersion.HTTP_2, version);
  req.end();
 });
 await();
}

private void testResponseBody(String expected) throws Exception {
 server.requestHandler(req -> {
  HttpServerResponse resp = req.response();
  resp.end(expected);
 });
 startServer();
 client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> {
  AtomicInteger count = new AtomicInteger();
  Buffer content = Buffer.buffer();
  resp.handler(buff -> {
   content.appendBuffer(buff);
   count.incrementAndGet();
  });
  resp.endHandler(v -> {
   assertTrue(count.get() > 0);
   assertEquals(expected, content.toString());
   testComplete();
  });
 }))
   .exceptionHandler(err -> fail())
   .end();
 await();
}

@Test
public void testHeadHasNoContentLengthByDefault() {
 server.requestHandler(req -> {
  assertEquals(HttpMethod.HEAD, req.method());
  // By default HEAD does not have a content-length header
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.HEAD, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertNull(resp.headers().get(HttpHeaders.CONTENT_LENGTH));
   resp.endHandler(v -> testComplete());
  })).end();
 }));
 await();
}

@Test
public void testResponseNoTrailers() {
 server.requestHandler(req -> {
  req.response().setChunked(true);
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertTrue(resp.trailers().isEmpty());
    testComplete();
   });
  })).end();
 }));
 await();
}

@Test
public void testHeadCanSetContentLength() {
 server.requestHandler(req -> {
  assertEquals(HttpMethod.HEAD, req.method());
  // Head never contains a body but it can contain a Content-Length header
  // Since headers from HEAD must correspond EXACTLY with corresponding headers for GET
  req.response().headers().set("Content-Length", String.valueOf(41));
  req.response().end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.HEAD, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals("41", resp.headers().get("Content-Length"));
   resp.endHandler(v -> testComplete());
  })).end();
 }));
 await();
}

@Test
public void testHeadButCanSetContentLength() {
 server.requestHandler(req -> {
  assertEquals(HttpMethod.HEAD, req.method());
  // By default HEAD does not have a content-length header but it can contain a content-length header
  // if explicitly set
  req.response().putHeader(HttpHeaders.CONTENT_LENGTH, "41").end();
 });
 server.listen(onSuccess(s -> {
  client.request(HttpMethod.HEAD, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   assertEquals("41", resp.headers().get(HttpHeaders.CONTENT_LENGTH));
   resp.endHandler(v -> testComplete());
  })).end();
 }));
 await();
}

@Test
public void testNoExceptionHandlerCalledWhenResponseEnded() throws Exception {
 server.requestHandler(req -> {
  HttpServerResponse resp = req.response();
  req.exceptionHandler(this::fail);
  resp.exceptionHandler(err -> {
   err.printStackTrace();
  });
  resp.end();
 }).listen(DEFAULT_HTTP_PORT, onSuccess(s -> {
  client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    vertx.setTimer(100, tid -> testComplete());
   });
   resp.exceptionHandler(t -> {
    fail("Should not be called");
   });
  })).exceptionHandler(t -> {
   fail("Should not be called");
  }).end();
 }));
 await();
}

@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 testHttpClientResponsePause(Handler<HttpClientResponse> h) throws Exception {
 server.requestHandler(req -> req.response().end("ok"));
 startServer();
 client.close();
 client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setKeepAlive(true));
 client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp1 -> {
  h.handle(resp1);
  vertx.setTimer(10, timerId -> {
   // The connection should be resumed as it's ended
   client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp2 -> {
    assertSame(resp1.request().connection(), resp2.request().connection());
    resp2.endHandler(v -> testComplete());
   }));
  });
 }));
 await();
}

@Test
public void test100ContinueHandledAutomatically() throws Exception {
 Buffer toSend = TestUtils.randomBuffer(1000);
 server.requestHandler(req -> {
  req.bodyHandler(data -> {
   assertEquals(toSend, data);
   req.response().end();
  });
 });
 server.listen(onSuccess(s -> {
  HttpClientRequest req = client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> testComplete());
  }));
  req.headers().set("Expect", "100-continue");
  req.setChunked(true);
  req.continueHandler(v -> {
   req.write(toSend);
   req.end();
  });
  req.sendHead();
 }));
 await();
}

@Test
public void testHttp11NonPersistentConnectionClosed() throws Exception {
 client.close();
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_1, req.version());
  assertEquals(req.getHeader("Connection"), "close");
  req.response().end();
  assertTrue(req.response().closed());
 });
 server.listen(onSuccess(s -> {
  client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setKeepAlive(false));
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertEquals(resp.getHeader("Connection"), "close");
    testComplete();
   });
  }));
  req.end();
 }));
 await();
}

@Test
public void testHttp10RequestNonKeepAliveConnectionClosed() throws Exception {
 client.close();
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_0, req.version());
  assertNull(req.getHeader("Connection"));
  req.response().end();
  assertTrue(req.response().closed());
 });
 server.listen(onSuccess(s -> {
  client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0).setKeepAlive(false));
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertNull(resp.getHeader("Connection"));
    testComplete();
   });
  }));
  req.end();
 }));
 await();
}

@Test
public void testHttp10KeepAliveConnectionNotClosed() throws Exception {
 client.close();
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_0, req.version());
  assertEquals(req.getHeader("Connection"), "keep-alive");
  req.response().end();
  assertFalse(req.response().closed());
 });
 server.listen(onSuccess(s -> {
  client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0).setKeepAlive(true));
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertEquals(resp.getHeader("Connection"), "keep-alive");
    assertEquals(resp.getHeader("Content-Length"), "0");
    testComplete();
   });
  }));
  req.end();
 }));
 await();
}

@Test
public void testHttp11PersistentConnectionNotClosed() throws Exception {
 client.close();
 server.requestHandler(req -> {
  assertEquals(HttpVersion.HTTP_1_1, req.version());
  assertNull(req.getHeader("Connection"));
  req.response().end();
  assertFalse(req.response().closed());
 });
 server.listen(onSuccess(s -> {
  client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setKeepAlive(true));
  HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> {
   resp.endHandler(v -> {
    assertNull(resp.getHeader("Connection"));
    assertEquals(resp.getHeader("Content-Length"), "0");
    testComplete();
   });
  }));
  req.end();
 }));
 await();
}

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
getHeader
Return the first header value with the specified name
handler
pause
resume
request
cookies
netSocket
Get a net socket for the underlying connection of this request. USE THIS WITH CAUTION! Writing to th

Popular in Java

Running tasks concurrently on multiple threads
onRequestPermissionsResult (Fragment)
setRequestProperty (URLConnection)
setContentView (Activity)
HttpServer (com.sun.net.httpserver)
This class implements a simple HTTP server. A HttpServer is bound to an IP address and port number a
LinkedList (java.util)
Doubly-linked list implementation of the List and Dequeinterfaces. Implements all optional list oper
Callable (java.util.concurrent)
A task that returns a result and may throw an exception. Implementors define a single method with no
JFileChooser (javax.swing)
JLabel (javax.swing)
Response (javax.ws.rs.core)
Defines the contract between a returned instance and the runtime when an application needs to provid

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

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

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