@Override public void start() throws Exception { HttpServer server = vertx.createHttpServer(new HttpServerOptions() .setSsl(true).setUseAlpn(true) .setPemKeyCertOptions(new PemKeyCertOptions() .setCertPath("server-cert.pem") .setKeyPath("server-key.pem") )); server.requestHandler(req -> { req.response() .putHeader("content-type", "text/html") .end("Hello using HTTP " + req.version()); }); server.listen(8443); } }
private void testServerWebsocketPingPongCheck(int maxFrameSize, Consumer<ServerWebSocket> check) { server = vertx.createHttpServer(new HttpServerOptions().setIdleTimeout(1).setPort(DEFAULT_HTTP_PORT).setHost(HttpTestBase.DEFAULT_HTTP_HOST).setMaxWebsocketFrameSize(maxFrameSize)); server.websocketHandler(ws -> { ws.pongHandler(buff -> fail()); check.accept(ws); }).listen(onSuccess(v -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> {}); })); await(); }
@Test public void testRedirectFromSSL() throws Exception { HttpServer redirectServer = vertx.createHttpServer(new HttpServerOptions() .setSsl(true) .setKeyStoreOptions(Cert.SERVER_JKS.get()) .setHost(DEFAULT_HTTP_HOST) .setPort(DEFAULT_HTTP_PORT) ).requestHandler(req -> { req.response().setStatusCode(303).putHeader("location", "http://" + DEFAULT_HTTP_HOST + ":4043/" + DEFAULT_TEST_URI).end(); }); startServer(redirectServer); RequestOptions options = new RequestOptions().setHost(DEFAULT_HTTP_HOST).setURI(DEFAULT_TEST_URI).setPort(4043); testTLS(Cert.NONE, Trust.SERVER_JKS, Cert.NONE, Trust.NONE) .clientSSL(true) .serverSSL(false) .requestOptions(options) .followRedirects(true) .pass(); } }
static HttpServerOptions createHttp2ServerOptions(int port, String host) { return new HttpServerOptions() .setPort(port) .setHost(host) .setUseAlpn(true) .setSsl(true) .addEnabledCipherSuite("TLS_RSA_WITH_AES_128_CBC_SHA") // Non Diffie-helman -> debuggable in wireshark .setKeyStoreOptions(Cert.SERVER_JKS.get()); };
@Override public void start() throws Exception { HttpServer server = vertx.createHttpServer(new HttpServerOptions().setSsl(true).setKeyStoreOptions( new JksOptions().setPath("server-keystore.jks").setPassword("wibble") )); server.requestHandler(req -> { req.response().putHeader("content-type", "text/html").end("<html><body><h1>Hello from vert.x!</h1></body></html>"); }).listen(4443); } }
@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 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(); }
@Test public void testContentDecompression() throws Exception { server.close(); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT).setDecompressionSupported(true)); String expected = TestUtils.randomAlphaString(1000); byte[] dataGzipped = TestUtils.compressGzip(expected); server.requestHandler(req -> { assertEquals("localhost:" + DEFAULT_HTTP_PORT, req.headers().get("host")); req.bodyHandler(buffer -> { assertEquals(expected, buffer.toString()); req.response().end(); }); }); server.listen(onSuccess(server -> { client .request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "some-uri", onSuccess(resp -> testComplete())) .putHeader("Content-Encoding", "gzip") .end(Buffer.buffer(dataGzipped)); })); await(); }
@Test public void testServerActualPortWhenZero() { server = vertx.createHttpServer(createBaseServerOptions().setPort(0).setHost(DEFAULT_HTTP_HOST)); server .requestHandler(request -> { request.response().end("hello"); }) .listen(ar -> { assertTrue(ar.result().actualPort() != 0); vertx.createHttpClient(createBaseClientOptions()).getNow(ar.result().actualPort(), DEFAULT_HTTP_HOST, "/", onSuccess(response -> { assertEquals(response.statusCode(), 200); response.bodyHandler(body -> { assertEquals(body.toString("UTF-8"), "hello"); testComplete(); }); })); }); await(); }
vertx.createHttpServer(new HttpServerOptions(). setUseAlpn(true). setSsl(true). setPemKeyCertOptions(new PemKeyCertOptions().setKeyPath("server-key.pem").setCertPath("server-cert.pem") )); server.requestHandler(req -> { String path = req.path(); HttpServerResponse resp = req.response(); if ("/".equals(path)) { resp.push(HttpMethod.GET, "/script.js", ar -> { if (ar.succeeded()) { System.out.println("sending push"); HttpServerResponse pushedResp = ar.result(); pushedResp.sendFile("script.js"); } else { resp.sendFile("index.html"); } else if ("/script.js".equals(path)) { resp.sendFile("script.js"); server.listen(8443, "localhost", ar -> { if (ar.succeeded()) { System.out.println("Server started");
@Override public void start() throws Exception { HttpServer server = vertx.createHttpServer(new HttpServerOptions(). setUseAlpn(true). setSsl(true). setPemKeyCertOptions(new PemKeyCertOptions().setKeyPath("server-key.pem").setCertPath("server-cert.pem") )); server.requestHandler(req -> { HttpServerResponse resp = req.response(); req.customFrameHandler(frame -> { System.out.println("Received client frame " + frame.payload().toString("UTF-8")); // Write the sam resp.writeCustomFrame(10, 0, Buffer.buffer("pong")); }); }).listen(8443); } }
@Test public void testFallbackOnHttp1() throws Exception { server.close(); server = vertx.createHttpServer(serverOptions.setUseAlpn(false)); server.requestHandler(req -> { assertEquals(HttpVersion.HTTP_1_1, req.version()); req.response().end(); }); startServer(); client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", resp -> { testComplete(); }).exceptionHandler(this::fail).end(); await(); }
@Test public void testCompressedResponseWithConnectionCloseAndNoCompressionHeader() throws Exception { Buffer expected = Buffer.buffer(TestUtils.randomAlphaString(2048)); server.close(); server = vertx.createHttpServer(new HttpServerOptions() .setPort(DEFAULT_HTTP_PORT) .setHost(DEFAULT_HTTP_HOST) .setCompressionSupported(true)); server.requestHandler(req -> { req.response().end(expected); }); startServer(); client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.bodyHandler(buff -> { assertEquals(expected, buff); complete(); }); })).putHeader("Connection", "close") .exceptionHandler(this::fail) .end(); await(); }
@Test public void testServerOpenSSL() throws Exception { HttpServerOptions opts = new HttpServerOptions() .setPort(DEFAULT_HTTPS_PORT) .setHost(DEFAULT_HTTPS_HOST) .setUseAlpn(true) .setSsl(true) .addEnabledCipherSuite("TLS_RSA_WITH_AES_128_CBC_SHA") // Non Diffie-helman -> debuggable in wireshark .setPemKeyCertOptions(Cert.SERVER_PEM.get()).setSslEngineOptions(new OpenSSLEngineOptions()); server.close(); client.close(); client = vertx.createHttpClient(createBaseClientOptions()); server = vertx.createHttpServer(opts); server.requestHandler(req -> { req.response().end(); }); CountDownLatch latch = new CountDownLatch(1); System.out.println("starting"); try { server.listen(onSuccess(v -> latch.countDown())); } catch (Throwable e) { e.printStackTrace(); client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { assertEquals(200, resp.statusCode()); testComplete();
@Test public void testHttp2() { vertx.createHttpServer(new HttpServerOptions() .setUseAlpn(true) .setSsl(true) .setSslEngineOptions(new OpenSSLEngineOptions()) .setKeyCertOptions(Cert.SERVER_JKS.get()) ) .requestHandler(req -> req.response().end("OK")) .listen(8443, "localhost", onSuccess(s -> { HttpClient client = vertx.createHttpClient(new HttpClientOptions() .setSsl(true) .setSslEngineOptions(new OpenSSLEngineOptions()) .setTrustStoreOptions(Trust.SERVER_JKS.get())); client.getNow(8443, "localhost", "/somepath", onSuccess(resp -> { resp.bodyHandler(buff -> { assertEquals("OK", buff.toString()); 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());
@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 testClientWebsocketWithHttp2Client() throws Exception { client.close(); client = vertx.createHttpClient(new HttpClientOptions().setHttp2ClearTextUpgrade(false).setProtocolVersion(HttpVersion.HTTP_2)); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); server.requestHandler(req -> { req.response().setChunked(true).write("connect"); }); server.websocketHandler(ws -> { ws.writeFinalTextFrame("ok"); }); server.listen(onSuccess(server -> { client.getNow(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", resp -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.handler(buff -> { assertEquals("ok", buff.toString()); testComplete(); }); }); }); })); await(); }
private void testServerMaxInitialLineLength(int maxInitialLength) { String longParam = TestUtils.randomAlphaString(5000); server.close(); server = vertx.createHttpServer(new HttpServerOptions().setMaxInitialLineLength(maxInitialLength) .setHost("localhost").setPort(8080)).requestHandler(req -> { assertEquals(req.getParam("t"), longParam); req.response().end(); }).listen(onSuccess(res -> { HttpClientRequest req = vertx.createHttpClient(new HttpClientOptions()) .request(HttpMethod.GET, 8080, "localhost", "/?t=" + longParam, onSuccess(resp -> { if (maxInitialLength > HttpServerOptions.DEFAULT_MAX_INITIAL_LINE_LENGTH) { assertEquals(200, resp.statusCode()); testComplete(); } else { assertEquals(414, resp.statusCode()); resp.request().connection().closeHandler(v -> { testComplete(); }); } })); req.end(); })); await(); }
@Test public void testUnmaskedFrameRequest(){ client = vertx.createHttpClient(new HttpClientOptions().setSendUnmaskedFrames(true)); server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT).setAcceptUnmaskedFrames(true)); server.requestHandler(req -> { req.response().setChunked(true).write("connect"); }); server.websocketHandler(ws -> { ws.handler(new Handler<Buffer>() { public void handle(Buffer data) { assertEquals(data.toString(), "first unmasked frame"); testComplete(); } }); }); server.listen(onSuccess(server -> { client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> { ws.writeFinalTextFrame("first unmasked frame"); }); })); await(); }