@Override public void handle(HttpServerRequest req) { if (req.headers() .contains(UPGRADE, WEBSOCKET, true) || handlers.requestHandler == null) { // Missing upgrade header + null request handler will be handled when creating the handshake by sending a 400 error handle((HttpServerRequestImpl) req); } else { handlers.requestHandler.handle(req); } }
@Override public String requestHeader(HttpServerRequest request, String name) { return request.headers().get(name); }
@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(); }
@Test public void testClientMultiThreaded() throws Exception { int numThreads = 10; Thread[] threads = new Thread[numThreads]; CountDownLatch latch = new CountDownLatch(numThreads); server.requestHandler(req -> { req.response().putHeader("count", req.headers().get("count")); req.response().end(); }).listen(ar -> { assertTrue(ar.succeeded()); for (int i = 0; i < numThreads; i++) { int index = i; threads[i] = new Thread() { public void run() { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(res -> { assertEquals(200, res.statusCode()); assertEquals(String.valueOf(index), res.headers().get("count")); latch.countDown(); })).putHeader("count", String.valueOf(index)).end(); } }; threads[i].start(); } }); awaitLatch(latch); for (int i = 0; i < numThreads; i++) { threads[i].join(); } }
private NetSocket getUpgradedNetSocket(HttpServerRequest req, String path) { assertEquals(path, req.path()); assertEquals("upgrade", req.headers().get("Connection")); NetSocket sock = req.netSocket(); String secHeader = req.headers().get("Sec-WebSocket-Key"); String tmp = secHeader + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; String encoded = sha1(tmp); sock.write("HTTP/1.1 101 Web Socket Protocol Handshake\r\n" + "Upgrade: WebSocket\r\n" + "Connection: upgrade\r\n" + "Sec-WebSocket-Accept: " + encoded + "\r\n" + "\r\n"); return sock; }
@Test public void testDefaultRequestHeaders() { Handler<HttpServerRequest> requestHandler = req -> { assertEquals(2, req.headers().size()); // 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(); }
@Test public void testRequestHeadersWithCharSequence() { HashMap<CharSequence, String> headers = new HashMap<>(); headers.put(HttpHeaders.TEXT_HTML, "text/html"); headers.put(HttpHeaders.USER_AGENT, "User-Agent"); headers.put(HttpHeaders.APPLICATION_X_WWW_FORM_URLENCODED, "application/x-www-form-urlencoded"); server.requestHandler(req -> { assertTrue(headers.size() < req.headers().size()); headers.forEach((k, v) -> assertEquals(v, req.headers().get(k))); headers.forEach((k, v) -> assertEquals(v, req.getHeader(k))); req.response().end(); }); server.listen(onSuccess(server -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()); headers.forEach((k, v) -> req.headers().add(k, v)); req.end(); })); await(); }
private void testRequestHeaders(boolean individually) { MultiMap headers = getHeaders(10); server.requestHandler(req -> { assertTrue(headers.size() < req.headers().size()); for (Map.Entry<String, String> entry : headers) { assertEquals(entry.getValue(), req.headers().get(entry.getKey())); assertEquals(entry.getValue(), req.getHeader(entry.getKey())); } req.response().end(); }); server.listen(onSuccess(server -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()); if (individually) { for (Map.Entry<String, String> header : headers) { req.headers().add(header.getKey(), header.getValue()); } } else { req.headers().setAll(headers); } req.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(); }
@Test public void testPutHeadersOnRequest() { server.requestHandler(req -> { assertEquals("bar", req.headers().get("foo")); assertEquals("bar", req.getHeader("foo")); req.response().end(); }); server.listen(onSuccess(server -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(200, resp.statusCode()); testComplete(); })).putHeader("foo", "bar").end(); })); await(); }
@Test public void testContainsValueStringIgnoreCase() { server.requestHandler(req -> { assertTrue(req.headers().contains("Foo", "foo", true)); assertTrue(req.headers().contains("Foo", "fOo", true)); 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", true)); assertTrue(resp.headers().contains("Quux", "quUx", true)); testComplete(); })); req.putHeader("foo", "foo"); req.end(); })); await(); }
@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 testHttpClientRequestHeadersDontContainCROrLF() throws Exception { server.requestHandler(req -> { req.headers().forEach(header -> { String name = header.getKey(); switch (name.toLowerCase()) {
@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(); }
String cnt = req.headers().get("count"); req.response().headers().set("count", cnt); req.response().end();
@Test public void testSkipEncoding() throws Exception { serverWithMaxCompressionLevel.requestHandler(req -> { assertNotNull(req.headers().get("Accept-Encoding")); req.response() .putHeader(HttpHeaders.CONTENT_ENCODING, HttpHeaders.IDENTITY) .end(Buffer.buffer(COMPRESS_TEST_STRING).toString(CharsetUtil.UTF_8)); }); startServer(serverWithMaxCompressionLevel); clientraw.get(DEFAULT_HTTP_PORT + 1, DEFAULT_HTTP_HOST, "some-uri", onSuccess(resp -> { resp.bodyHandler(responseBuffer -> { String responseBody = responseBuffer.toString(CharsetUtil.UTF_8); assertEquals(COMPRESS_TEST_STRING, responseBody); testComplete(); }); })).putHeader(HttpHeaders.ACCEPT_ENCODING, HttpHeaders.DEFLATE_GZIP).end(); await(); }
@Test public void testContainsValueCharSequenceIgnoreCase() { CharSequence Foo = HttpHeaders.createOptimized("Foo"); CharSequence foo = HttpHeaders.createOptimized("foo"); CharSequence fOo = HttpHeaders.createOptimized("fOo"); CharSequence Quux = HttpHeaders.createOptimized("Quux"); CharSequence quux = HttpHeaders.createOptimized("quux"); CharSequence quUx = HttpHeaders.createOptimized("quUx"); server.requestHandler(req -> { assertTrue(req.headers().contains(Foo, foo, true)); assertTrue(req.headers().contains(Foo, fOo, true)); 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, true)); assertTrue(resp.headers().contains(Quux, quUx, true)); testComplete(); })); req.putHeader(foo, foo); req.end(); })); await(); }
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());
@Test public void testContainsValueCharSequence() { CharSequence Foo = HttpHeaders.createOptimized("Foo"); CharSequence foo = HttpHeaders.createOptimized("foo"); CharSequence fOo = HttpHeaders.createOptimized("fOo"); CharSequence Quux = HttpHeaders.createOptimized("Quux"); CharSequence quux = HttpHeaders.createOptimized("quux"); CharSequence quUx = HttpHeaders.createOptimized("quUx"); 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 testLowerCaseHeaders() { server.requestHandler(req -> { assertEquals("foo", req.headers().get("Foo")); assertEquals("foo", req.headers().get("foo")); assertEquals("foo", req.headers().get("fOO")); assertTrue(req.headers().contains("Foo")); assertTrue(req.headers().contains("foo")); assertTrue(req.headers().contains("fOO"));