/** * Convenience method for receiving the entire request body in one piece. * <p> * This saves the user having to manually setting a data and end handler and append the chunks of the body until * the whole body received. Don't use this if your request body is large - you could potentially run out of RAM. * * @param bodyHandler This handler will be called after all the body has been received */ @Fluent default HttpServerRequest bodyHandler(@Nullable Handler<Buffer> bodyHandler) { if (bodyHandler != null) { Buffer body = Buffer.buffer(); handler(body::appendBuffer); endHandler(v -> bodyHandler.handle(body)); } return this; }
@Override public void start() throws Exception { vertx.createHttpServer().requestHandler(req -> { System.out.println("Got request " + req.uri()); for (String name : req.headers().names()) { System.out.println(name + ": " + req.headers().get(name)); } req.handler(data -> System.out.println("Got data " + data.toString("ISO-8859-1"))); req.endHandler(v -> { // Now send back a response req.response().setChunked(true); for (int i = 0; i < 10; i++) { req.response().write("server-data-chunk-" + i); } req.response().end(); }); }).listen(8282); }
@Override public void start() throws Exception { SelfSignedCertificate certificate = SelfSignedCertificate.create(); HttpServerOptions serverOptions = new HttpServerOptions() .setSsl(true) .setKeyCertOptions(certificate.keyCertOptions()); vertx.createHttpServer(serverOptions).requestHandler(req -> { System.out.println("Got request " + req.uri()); for (String name : req.headers().names()) { System.out.println(name + ": " + req.headers().get(name)); } req.handler(data -> System.out.println("Got data " + data.toString("ISO-8859-1"))); req.endHandler(v -> { // Now send back a response req.response().setChunked(true); for (int i = 0; i < 10; i++) { req.response().write("server-data-chunk-" + i); } req.response().end(); }); }).listen(8282); }
@Test public void testClientConnectionClose() throws Exception { // Test client connection close + server close handler CountDownLatch latch = new CountDownLatch(1); server.requestHandler(req -> { AtomicInteger len = new AtomicInteger(); req.handler(buff -> { if (len.addAndGet(buff.length()) == 1024) { latch.countDown(); } }); req.connection().closeHandler(v -> { testComplete(); }); }); CountDownLatch listenLatch = new CountDownLatch(1); server.listen(onSuccess(s -> listenLatch.countDown())); awaitLatch(listenLatch); HttpClientRequest req = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(err -> {})); req.setChunked(true); req.write(TestUtils.randomBuffer(1024)); awaitLatch(latch); req.connection().close(); await(); }
@Override public void start() throws Exception { HttpClient client = vertx.createHttpClient(new HttpClientOptions()); vertx.createHttpServer().requestHandler(req -> { System.out.println("Proxying request: " + req.uri()); HttpClientRequest c_req = client.request(req.method(), 8282, "localhost", req.uri(), c_res -> { System.out.println("Proxying response: " + c_res.statusCode()); req.response().setChunked(true); req.response().setStatusCode(c_res.statusCode()); req.response().headers().setAll(c_res.headers()); c_res.handler(data -> { System.out.println("Proxying response body: " + data.toString("ISO-8859-1")); req.response().write(data); }); c_res.endHandler((v) -> req.response().end()); }); c_req.setChunked(true); c_req.headers().setAll(req.headers()); req.handler(data -> { System.out.println("Proxying request body " + data.toString("ISO-8859-1")); c_req.write(data); }); req.endHandler((v) -> c_req.end()); }).listen(8080); } }
private void pausingServer(Consumer<Future<Void>> consumer) { Future<Void> resumeFuture = Future.future(); server.requestHandler(req -> { req.response().setChunked(true); req.pause(); Context ctx = vertx.getOrCreateContext(); resumeFuture.setHandler(v1 -> { ctx.runOnContext(v2 -> { req.resume(); }); }); req.handler(buff -> { req.response().write(buff); }); }); server.listen(onSuccess(s -> consumer.accept(resumeFuture))); }
req.pause(); paused.set(true); req.handler(content::appendBuffer); req.endHandler(v -> { assertEquals(expected, content);
Buffer readBuffer = Buffer.buffer(64 * 1024 * 1024); server.requestHandler(request -> { request.handler(b -> { readBuffer.appendBuffer(b); request.pause();
Future<Void> bufReceived = Future.future(); server.requestHandler(req -> { req.handler(buf -> { bufReceived.complete(); });
AtomicBoolean paused = new AtomicBoolean(true); Buffer body = Buffer.buffer(); req.handler(buff -> { assertFalse(paused.get()); body.appendBuffer(buff);
private void testPost(String expected) throws Exception { Buffer content = Buffer.buffer(); AtomicInteger count = new AtomicInteger(); server.requestHandler(req -> { assertEquals(HttpMethod.POST, req.method()); req.handler(buff -> { content.appendBuffer(buff); count.getAndIncrement(); }); req.endHandler(v -> { assertTrue(count.get() > 0); req.response().end(); }); }); startServer(); client.post(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { resp.endHandler(v -> { assertEquals(expected, content.toString()); testComplete(); }); })).exceptionHandler(err -> { fail(); }).end(expected); await(); }
assertEquals(protocol, req.version()); requestBeginLatch.countDown(); req.handler(buff -> { requestBodyLatch.countDown(); });
if (redirect) { Buffer body = Buffer.buffer(); req.handler(buff -> { if (body.length() == 0) { HttpServerResponse resp = req.response();
@Test public void testClientRequestExceptionHandlerCalledWhenConnectionClosed() throws Exception { server.requestHandler(req -> { req.handler(buff -> { req.connection().close(); }); }); startServer(); HttpClientRequest req = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(err -> {})).setChunked(true); req.exceptionHandler(err -> { testComplete(); }); req.write("chunk"); await(); }
@Test public void testPausedHttpServerRequestDuringLastChunkEndsTheRequest() throws Exception { server.requestHandler(req -> { req.handler(buff -> { assertEquals("small", buff.toString()); req.pause(); }); req.endHandler(v -> { req.response().end(); }); }); startServer(); client.close(); client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(1)); client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", resp -> { complete(); }).end("small"); await(); }
@Test public void testPausedHttpServerRequestUnpauseTheConnectionAtRequestEnd() throws Exception { int numRequests = 20; waitFor(numRequests); server.requestHandler(req -> { req.handler(buff -> { assertEquals("small", buff.toString()); req.pause(); }); req.endHandler(v -> { req.response().end(); }); }); startServer(); client.close(); client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(1)); for (int i = 0; i < numRequests; i++) { client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", resp -> { complete(); }).end("small"); } }
assertTrue(Context.isOnWorkerThread()); Buffer buf = Buffer.buffer(); req.handler(buf::appendBuffer); req.endHandler(v -> { assertEquals("hello", buf.toString());
req.handler(v2 -> { }); fail("Shouldn't be able to set handler");
req.handler(v2 -> { }); fail("Shouldn't be able to set handler");
@Test public void testServerResetClientStreamDuringRequest() throws Exception { String chunk = TestUtils.randomAlphaString(1024); server.requestHandler(req -> { req.handler(buf -> { req.response().reset(8); }); }); startServer(); client.post(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onFailure(resp -> {})) .exceptionHandler(err -> { Context ctx = Vertx.currentContext(); assertOnIOContext(ctx); assertTrue(err instanceof StreamResetException); StreamResetException reset = (StreamResetException) err; assertEquals(8, reset.getCode()); testComplete(); }).setChunked(true).write(chunk); await(); }