@Override public void start() throws Exception { Router router = Router.router(vertx); router.route().handler(routingContext -> { routingContext.response().putHeader("content-type", "text/html").end("Hello World!"); }); vertx.createHttpServer().requestHandler(router).listen(8080); } }
@Override public void start() { Router router = Router.router(vertx); router.get("/").handler(rc -> { String param = rc.request().getParam("name"); if (param == null) { param = "world"; } vertx.eventBus().<String>send("request", param, reply -> { if (reply.failed()) { rc.response().setStatusCode(400).end(reply.cause().getMessage()); } else { String content = reply.result().body(); rc.response().end(content); } }); }); vertx.createHttpServer() .requestHandler(router) .listen(8080); } }
@Test public void testServerChaining() { server.requestHandler(req -> { assertTrue(req.response().setChunked(true) == req.response()); assertTrue(req.response().write("foo", "UTF-8") == req.response()); assertTrue(req.response().write("foo") == req.response()); testComplete(); }); server.listen(onSuccess(server -> { client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()).end(); })); await(); }
private void hello(RoutingContext context) { logger.info("Hello request from {}", context.request().remoteAddress()); context.response() .putHeader("Content-Type", "text/plain") .end("Hello from Vert.x!"); }
@Override public void start() throws Exception { Router router = Router.router(vertx); router.route().handler(BodyHandler.create()); router.route("/").handler(routingContext -> { routingContext.response().putHeader("content-type", "text/html").end( "<form action=\"/form\" method=\"post\">\n" + " <div>\n" + router.post("/form").handler(ctx -> { ctx.response().putHeader(HttpHeaders.CONTENT_TYPE, "text/plain"); ctx.response().end("Hello " + ctx.request().getParam("name") + "!"); }); vertx.createHttpServer().requestHandler(router).listen(8080);
@Test public void testRoutePathOnlyBegin() throws Exception { String path1 = "/blah"; router.route(path1 + "*").handler(rc -> rc.response().setStatusCode(200).setStatusMessage(rc.request().path()).end()); String path2 = "/quux"; router.route(path2 + "*").handler(rc -> rc.response().setStatusCode(200).setStatusMessage(rc.request().path()).end()); testPathBegin(path1); testPathBegin(path2); }
@Test public void testRequestBodyBufferAtEnd() { Buffer body = TestUtils.randomBuffer(1000); server.requestHandler(req -> req.bodyHandler(buffer -> { assertEquals(body, buffer); req.response().end(); })); server.listen(onSuccess(server -> { client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()).end(body); })); await(); }
@Test public void testPutHeaderReplacesPreviousHeaders() throws Exception { server.requestHandler(req -> req.response() .putHeader("Location", "http://example1.org") .putHeader("location", "http://example2.org") .end()); server.listen(onSuccess(server -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(singletonList("http://example2.org"), resp.headers().getAll("LocatioN")); testComplete(); })).end(); })); await(); }
@Test public void testPipeliningOrder() throws Exception { client.close(); client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(true).setPipelining(true).setMaxPoolSize(1)); int requests = 100; server.requestHandler(req -> { int theCount = reqCount.get(); assertEquals(theCount, Integer.parseInt(req.headers().get("count"))); reqCount.incrementAndGet(); req.response().setChunked(true); req.bodyHandler(buff -> { assertEquals("This is content " + theCount, buff.toString()); vertx.setTimer(1 + (long) (10 * Math.random()), id -> { req.response().headers().set("count", String.valueOf(theCount)); req.response().write(buff); req.response().end(); }); }); server.listen(onSuccess(s -> { vertx.setTimer(500, id -> { for (int count = 0; count < requests; count++) { int theCount = count; HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(theCount, Integer.parseInt(resp.headers().get("count"))); resp.bodyHandler(buff -> {
@Test public void testUnknownContentLengthIsSetToZeroWithHTTP_1_0() throws Exception { server.requestHandler(req -> { req.response().write("Some-String").end(); }); startServer(); client.close(); client = vertx.createHttpClient(new HttpClientOptions().setProtocolVersion(HttpVersion.HTTP_1_0)); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertNull(resp.getHeader("Content-Length")); testComplete(); })); await(); }
RequestParameters params = routingContext.get("parsedParameters"); routingContext.response().setStatusMessage("OK").end(); }); Throwable failure = routingContext.failure(); if (failure instanceof ValidationException) routingContext.response() .setStatusCode(400) .setStatusMessage("ValidationException thrown! " + ((ValidationException) failure).type().name()) .end(); }); server = vertx.createHttpServer(new HttpServerOptions().setPort(8080).setHost("localhost")); server.requestHandler(router).listen((ar) -> { if (ar.succeeded()) { logger.info("Server started on port " + ar.result().actualPort()); future.complete(); } else {
@Test public void testRedirectToSSL() throws Exception { HttpServer redirectServer = vertx.createHttpServer(new HttpServerOptions() .setHost(DEFAULT_HTTP_HOST) .setPort(DEFAULT_HTTP_PORT) ).requestHandler(req -> { req.response().setStatusCode(303).putHeader("location", "https://" + DEFAULT_HTTP_HOST + ":4043/" + DEFAULT_TEST_URI).end(); }); startServer(redirectServer); RequestOptions options = new RequestOptions().setHost(DEFAULT_HTTP_HOST).setURI(DEFAULT_TEST_URI).setPort(DEFAULT_HTTP_PORT); testTLS(Cert.NONE, Trust.SERVER_JKS, Cert.SERVER_JKS, Trust.NONE) .clientSSL(false) .serverSSL(true) .requestOptions(options) .followRedirects(true) .pass(); }
@Test public void testSendFileNotFound() throws Exception { server.requestHandler(req -> { req.response().putHeader("Content-Type", "wibble"); req.response().sendFile("nosuchfile.html"); }); server.listen(onSuccess(s -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> {})).end(); vertx.setTimer(100, tid -> testComplete()); })); await(); }
System.setProperty("vertx.disableH2c", "true"); try { server.close(); server = vertx.createHttpServer(serverOptions.setUseAlpn(false).setSsl(false).setHost(DEFAULT_HTTP_HOST).setPort(DEFAULT_HTTP_PORT)); server.requestHandler(req -> { MultiMap headers = req.headers(); String upgrade = headers.get("upgrade"); assertEquals(DEFAULT_HTTP_HOST + ":" + DEFAULT_HTTP_PORT, req.host()); if ("h2c".equals(upgrade)) { req.response().setStatusCode(400).end(); } else { req.response().end("wibble"); assertEquals(HttpVersion.HTTP_1_1, req.version()); }); startServer(); client.close(); client = vertx.createHttpClient(clientOptions.setUseAlpn(false).setSsl(false)); client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { assertEquals(400, resp.statusCode()); assertEquals(HttpVersion.HTTP_1_1, resp.version());
private void testFollowRedirectWithBody(Function<Buffer, Buffer> translator) throws Exception { Buffer expected = TestUtils.randomBuffer(2048); AtomicBoolean redirected = new AtomicBoolean(); server.requestHandler(req -> { if (redirected.compareAndSet(false, true)) { assertEquals(HttpMethod.PUT, req.method()); req.bodyHandler(body -> { assertEquals(body, expected); String scheme = createBaseServerOptions().isSsl() ? "https" : "http"; req.response().setStatusCode(303).putHeader(HttpHeaders.LOCATION, scheme + "://localhost:8080/whatever").end(); }); } else { assertEquals(HttpMethod.GET, req.method()); req.response().end(); } }); startServer(); client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { assertEquals(200, resp.statusCode()); testComplete(); })).setFollowRedirects(true).end(translator.apply(expected)); await(); }
@Test public void test100ContinueRejectedManually() throws Exception { server.close(); server = vertx.createHttpServer(createBaseServerOptions()); server.requestHandler(req -> { req.response().setStatusCode(405).end(); req.bodyHandler(data -> { fail("body should not be received"); }); }); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(405, resp.statusCode()); testComplete(); })); req.headers().set("Expect", "100-continue"); req.setChunked(true); req.continueHandler(v -> { fail("should not be called"); }); req.sendHead(); })); await(); }
@Test public void testClientMaxHeaderSizeOption() { String longHeader = TestUtils.randomAlphaString(9000); // min 9023 = 9000 for longHeader and 23 for "Content-Length: 0 t: " vertx.createHttpServer(new HttpServerOptions().setHost(DEFAULT_HTTP_HOST).setPort(DEFAULT_HTTP_PORT)).requestHandler(req -> { // Add longHeader req.response().putHeader("t", longHeader).end(); }).listen(onSuccess(res -> { HttpClientRequest req = vertx.createHttpClient(new HttpClientOptions().setMaxHeaderSize(10000)) .request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> { assertEquals(200, resp.statusCode()); assertEquals(resp.getHeader("t"), longHeader); testComplete(); })); req.end(); })); await(); }
@Test public void testHandleInvalid204Response() throws Exception { int numReq = 3; waitFor(numReq); client.close(); client = vertx.createHttpClient(new HttpClientOptions().setPipelining(true).setKeepAlive(true).setMaxPoolSize(1)); server.requestHandler(r -> { // Generate an invalid response for the pipe-lined r.response().setChunked(true).setStatusCode(204).end(); }).listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v1 -> { for (int i = 0;i < numReq;i++) { AtomicInteger count = new AtomicInteger(); HttpClientRequest post = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(r -> { r.endHandler(v2 -> { complete(); }); })).exceptionHandler(err -> { if (count.incrementAndGet() == 1) { complete(); } }); post.end(); } })); await(); }
@Test public void testFollowRedirectPropagatesTimeout() throws Exception { AtomicInteger redirections = new AtomicInteger(); server.requestHandler(req -> { switch (redirections.getAndIncrement()) { case 0: String scheme = createBaseServerOptions().isSsl() ? "https" : "http"; req.response().setStatusCode(307).putHeader(HttpHeaders.LOCATION, scheme + "://localhost:8080/whatever").end(); break; } }); startServer(); AtomicBoolean done = new AtomicBoolean(); client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onFailure(t -> { if (done.compareAndSet(false, true)) { assertEquals(2, redirections.get()); testComplete(); } })).setFollowRedirects(true) .setTimeout(500).end(); await(); }
@Test public void testFollowRedirectHost() throws Exception { String scheme = createBaseClientOptions().isSsl() ? "https" : "http"; waitFor(2); HttpServerOptions options = createBaseServerOptions(); int port = options.getPort() + 1; options.setPort(port); AtomicInteger redirects = new AtomicInteger(); server.requestHandler(req -> { redirects.incrementAndGet(); req.response().setStatusCode(301).putHeader(HttpHeaders.LOCATION, scheme + "://localhost:" + port + "/whatever").end(); }); startServer(); HttpServer server2 = vertx.createHttpServer(options); server2.requestHandler(req -> { assertEquals(1, redirects.get()); assertEquals(scheme + "://localhost:" + port + "/whatever", req.absoluteURI()); req.response().end(); complete(); }); startServer(server2); client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { assertEquals(scheme + "://localhost:" + port + "/whatever", resp.request().absoluteURI()); complete(); })).setFollowRedirects(true).setHost("localhost:" + options.getPort()).end(); await(); }