@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); } }
.put("path", ctx.request().path()); ctx.response().end(res.result()); } else { ctx.fail(res.cause()); vertx.createHttpServer().requestHandler(router).listen(8080);
@Override public void start(Future<Void> startFuture) throws Exception { vertx.createHttpServer().requestHandler(request -> { String name = request.getParam("name"); LOG.info("Got request for name: " + name); if (name == null) { request.response().setStatusCode(400).end("Missing name"); } else { // It's fine to call the greeter from the event loop as it's not blocking request.response().end(greeter.sayHello(name)); } }).listen(8080, ar -> { if (ar.succeeded()) { LOG.info("GreetingVerticle started: @" + this.hashCode()); startFuture.complete(); } else { startFuture.fail(ar.cause()); } }); } }
static String absoluteURI(String serverOrigin, HttpServerRequest req) throws URISyntaxException { String absoluteURI; URI uri = new URI(req.uri()); String scheme = uri.getScheme(); if (scheme != null && (scheme.equals("http") || scheme.equals("https"))) { absoluteURI = uri.toString(); } else { String host = req.host(); if (host != null) { absoluteURI = req.scheme() + "://" + host + uri; } else { // Fall back to the server origin absoluteURI = serverOrigin + uri; } } return absoluteURI; }
@Override public void start() throws Exception { vertx.createHttpServer().websocketHandler(ws -> ws.handler(ws::writeBinaryMessage)).requestHandler(req -> { if (req.uri().equals("/")) req.response().sendFile("ws.html"); }).listen(8080); } }
@Override public void start() throws Exception { vertx.createHttpServer().requestHandler(req -> { if (req.uri().equals("/")) { // Serve the index page req.response().sendFile("index.html"); } else if (req.uri().startsWith("/form")) { req.response().setChunked(true); req.setExpectMultipart(true); req.endHandler((v) -> { for (String attr : req.formAttributes().names()) { req.response().write("Got attr " + attr + " : " + req.formAttributes().get(attr) + "\n"); } req.response().end(); }); } else { req.response().setStatusCode(404).end(); } }).listen(8080); } }
@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(); }
HttpServerOptions options = new HttpServerOptions(); options.setHost("localhost").setPort(PORT); server = vertx.createHttpServer(options); server.requestHandler(request -> { HttpMethod method = request.method(); String uri = request.uri(); if (username != null) { String auth = request.getHeader("Proxy-Authorization"); String expected = "Basic " + Base64.getEncoder().encodeToString((username + ":" + username).getBytes()); if (auth == null || !auth.equals(expected)) { request.response().setStatusCode(407).end("proxy authentication failed"); return; lastRequestHeaders = MultiMap.caseInsensitiveMultiMap().addAll(request.headers()); if (error != 0) { request.response().setStatusCode(error).end("proxy request failed"); } else if (method == HttpMethod.CONNECT) { if (!uri.contains(":")) { request.response().setStatusCode(403).end("invalid request"); } else { lastUri = uri; request.response().setStatusCode(403).end("access to port denied"); return; NetClient netClient = vertx.createNetClient(netOptions); netClient.connect(port, host, result -> { if (result.succeeded()) { NetSocket serverSocket = request.netSocket();
@Test public void testFormUploadAttributes() throws Exception { AtomicInteger attributeCount = new AtomicInteger(); server.requestHandler(req -> { if (req.method() == HttpMethod.POST) { assertEquals(req.path(), "/form"); req.response().setChunked(true); req.setExpectMultipart(true); req.uploadHandler(upload -> upload.handler(buffer -> { fail("Should get here"); })); req.endHandler(v -> { MultiMap attrs = req.formAttributes(); attributeCount.set(attrs.size()); assertEquals("vert x", attrs.get("framework")); assertEquals("vert x", req.getFormAttribute("framework")); assertEquals("jvm", attrs.get("runson")); assertEquals("jvm", req.getFormAttribute("runson")); req.response().end(); }); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/form", onSuccess(resp -> { assertEquals(200, resp.statusCode()); resp.bodyHandler(body -> { assertEquals(0, body.length()); });
@Test public void testContainsValueString() { server.requestHandler(req -> { assertTrue(req.headers().contains("Foo", "foo", false)); assertFalse(req.headers().contains("Foo", "fOo", false)); req.response().putHeader("quux", "quux"); req.response().end(); }); server.listen(onSuccess(server -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertTrue(resp.headers().contains("Quux", "quux", false)); assertFalse(resp.headers().contains("Quux", "quUx", false)); testComplete(); })); req.putHeader("foo", "foo"); req.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 testHeaders() throws Exception { AtomicInteger reqCount = new AtomicInteger(); server.requestHandler(req -> { assertEquals("https", req.scheme()); assertEquals(HttpMethod.GET, req.method()); assertEquals("/somepath", req.path()); assertEquals(DEFAULT_HTTPS_HOST_AND_PORT, req.host()); assertEquals("foo_request_value", req.getHeader("Foo_request")); assertEquals("bar_request_value", req.getHeader("bar_request")); assertEquals(2, req.headers().getAll("juu_request").size()); assertEquals("juu_request_value_1", req.headers().getAll("juu_request").get(0)); assertEquals("juu_request_value_2", req.headers().getAll("juu_request").get(1)); reqCount.incrementAndGet(); HttpServerResponse resp = req.response(); resp.putHeader("content-type", "text/plain"); resp.putHeader("Foo_response", "foo_value"); resp.putHeader("bar_response", "bar_value"); testComplete(); }); })).putHeader("Foo_request", "foo_request_value") .putHeader("bar_request", "bar_request_value")
@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); } }
@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); }
@Test public void testSendFileFromClasspath() { vertx.createHttpServer(new HttpServerOptions().setPort(8080)).requestHandler(res -> { res.response().sendFile(webRoot + "/somefile.html"); }).listen(onSuccess(res -> { vertx.createHttpClient(new HttpClientOptions()).request(HttpMethod.GET, 8080, "localhost", "/", onSuccess(resp -> { resp.bodyHandler(buff -> { assertTrue(buff.toString().startsWith("<html><body>blah</body></html>")); testComplete(); }); })).end(); })); await(); }
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(); }
List<String> authorities = new ArrayList<>(); for (String authority : ctx.request().params().getAll("authority")) { authorities.add(authority); ctx.response().putHeader("Content-Type", "text/plain"); ctx.response().end(jwt.generateToken(new JsonObject(), new JWTOptions().setExpiresInSeconds(60).setPermissions (authorities))); }); ctx.response().putHeader("Content-Type", "text/plain"); ctx.response().end("this secret is not defcon!"); }); vertx.createHttpServer().requestHandler(router).listen(8080);
@Test public void testNoParams() { server.requestHandler(req -> { assertNull(req.query()); assertTrue(req.params().isEmpty()); req.response().end(); }); server.listen(onSuccess(server -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()).end(); })); await(); }
HttpServerResponse httpServerResponse = ctx.response(); httpServerResponse.setChunked(true); MultiMap headers = ctx.request().headers(); for (String key : headers.names()) { httpServerResponse.write(key + ": "); httpServerResponse.write(headers.get(key)); httpServerResponse.write("<br>"); HttpServerResponse httpServerResponse = ctx.response(); httpServerResponse.setChunked(true); MultiMap headers = ctx.request().headers(); for (String key : headers.names()) { httpServerResponse.write(key + ": "); vertx.createHttpServer().requestHandler(router).listen(8080);
@Test public void testBeginPipelinedRequestByResponseSentBeforeRequestCompletion() throws Exception { server.requestHandler(req -> { if (req.method() == HttpMethod.POST) { req.pause(); vertx.setTimer(100, id1 -> { req.response().end(); vertx.setTimer(100, id2 -> { req.resume(); }); }); } else if (req.method() == HttpMethod.GET) { req.response().end(); } }); startServer(); client.close(); client = vertx.createHttpClient(new HttpClientOptions().setPipelining(true).setMaxPoolSize(1).setKeepAlive(true)); client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> { }).end(TestUtils.randomAlphaString(1024)); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", resp -> { testComplete(); }); await(); }