@Override public void start() throws Exception { HttpServer server = vertx.createHttpServer(new HttpServerOptions()); server.requestHandler(req -> { req.response().putHeader("content-type", "text/html").end("<html><body>" + "<h1>Hello from vert.x!</h1>" + "<p>version = " + req.version() + "</p>" + "</body></html>"); }).listen(8080); } }
@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); } }
@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 -> { req.response().putHeader("content-type", "text/html").end("<html><body>" + "<h1>Hello from vert.x!</h1>" + "<p>version = " + req.version() + "</p>" + "</body></html>"); }).listen(8443); } }
@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 testSimpleRequest(String uri, HttpMethod method, HttpClientRequest request, boolean absolute) { int index = uri.indexOf('?'); String query; String path; if (index == -1) { path = uri; query = null; } else { path = uri.substring(0, index); query = uri.substring(index + 1); } String resource = absolute && path.isEmpty() ? "/" + path : path; server.requestHandler(req -> { String expectedPath = req.method() == HttpMethod.CONNECT && req.version() == HttpVersion.HTTP_2 ? null : resource; String expectedQuery = req.method() == HttpMethod.CONNECT && req.version() == HttpVersion.HTTP_2 ? null : query; assertEquals(expectedPath, req.path()); assertEquals(method, req.method()); assertEquals(expectedQuery, req.query()); req.response().end(); }); server.listen(onSuccess(server -> request.end())); await(); }
@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 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 testDefaultRequestHeaders() { Handler<HttpServerRequest> requestHandler = req -> { // assertEquals(2, req.headers().size()); assertEquals(HttpVersion.HTTP_2, req.version()); // assertEquals("localhost:" + DEFAULT_HTTP_PORT, req.headers().get("host")); assertNotNull(req.headers().get("Accept-Encoding")); req.response().end(Buffer.buffer(COMPRESS_TEST_STRING).toString(CharsetUtil.UTF_8)); }; serverWithMinCompressionLevel.requestHandler(requestHandler); serverWithMaxCompressionLevel.requestHandler(requestHandler); serverWithMinCompressionLevel.listen(onSuccess(serverReady -> { testMinCompression(); testRawMinCompression(); })); serverWithMaxCompressionLevel.listen(onSuccess(serverReady -> { testMaxCompression(); testRawMaxCompression(); })); await(); }
req.method(); } else { req.version();
CompletableFuture<Void> endResponse = new CompletableFuture<>(); server.requestHandler(req -> { assertEquals(protocol, req.version()); requestBeginLatch.countDown(); req.handler(buff -> {
AtomicReference<HttpServerMetric> serverMetric = new AtomicReference<>(); server.requestHandler(req -> { assertEquals(protocol, req.version()); FakeHttpServerMetrics serverMetrics = FakeMetricsBase.getMetrics(server); assertNotNull(serverMetrics);
@Test public void testServerDoesNotSupportAlpn() throws Exception { waitFor(2); server.close(); server = vertx.createHttpServer(createBaseServerOptions().setUseAlpn(false)); server.requestHandler(req -> { assertEquals(HttpVersion.HTTP_1_1, req.version()); req.response().end(); complete(); }); startServer(); client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(HttpVersion.HTTP_1_1, resp.version()); complete(); })).exceptionHandler(this::fail).end(); await(); }
@Test public void testClientDoesNotSupportAlpn() throws Exception { waitFor(2); server.requestHandler(req -> { assertEquals(HttpVersion.HTTP_1_1, req.version()); req.response().end(); complete(); }); startServer(); client.close(); client = vertx.createHttpClient(createBaseClientOptions().setProtocolVersion(HttpVersion.HTTP_1_1).setUseAlpn(false)); client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(HttpVersion.HTTP_1_1, resp.version()); complete(); })).exceptionHandler(this::fail).end(); await(); }
req.response().end("wibble"); assertEquals(HttpVersion.HTTP_1_1, req.version()); }); startServer();
@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 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 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(); }
@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 testDefaultRequestHeaders() { server.requestHandler(req -> { if (req.version() == HttpVersion.HTTP_1_1) { assertEquals(1, req.headers().size()); assertEquals("localhost:" + DEFAULT_HTTP_PORT, req.headers().get("host")); } else { assertEquals(4, req.headers().size()); assertEquals("https", req.headers().get(":scheme")); assertEquals("GET", req.headers().get(":method")); assertEquals("some-uri", req.headers().get(":path")); assertEquals("localhost:" + DEFAULT_HTTP_PORT, req.headers().get(":authority")); } req.response().end(); }); server.listen(onSuccess(server -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()).end(); })); await(); }
assertEquals(req.version(), version); assertTrue(req.isSSL()); req.response().end();