@Override public String get(HttpServerRequest carrier, String key) { return carrier.getHeader(key); }
@Override public void start() throws Exception { vertx.createHttpServer().requestHandler(req -> { System.out.println("Got form with content-type " + req.getHeader("content-type")); req.setExpectMultipart(true); req.endHandler(v -> { System.out.println("firstName: " + req.getFormAttribute("firstName")); System.out.println("lastName: " + req.getFormAttribute("lastName")); System.out.println("male: " + req.getFormAttribute("male")); req.response().end(); }); }).listen(8080, listenResult -> { if (listenResult.failed()) { System.out.println("Could not start HTTP server"); listenResult.cause().printStackTrace(); } else { System.out.println("Server started"); } }); } }
@Override public void start() throws Exception { vertx.createHttpServer().requestHandler(req -> { System.out.println("Got form with content-type " + req.getHeader("content-type")); req.setExpectMultipart(true); req.endHandler(v -> { System.out.println("firstName: " + req.getFormAttribute("firstName")); System.out.println("lastName: " + req.getFormAttribute("lastName")); System.out.println("male: " + req.getFormAttribute("male")); req.response().end(); }); }).listen(8080, listenResult -> { if (listenResult.failed()) { System.out.println("Could not start HTTP server"); listenResult.cause().printStackTrace(); } else { System.out.println("Server started"); } }); } }
private NetSocket handshake(HttpServerRequest req) { NetSocket so = req.netSocket(); try { MessageDigest digest = MessageDigest.getInstance("SHA-1"); byte[] inputBytes = (req.getHeader("Sec-WebSocket-Key") + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").getBytes(); digest.update(inputBytes); byte[] hashedBytes = digest.digest(); byte[] accept = Base64.getEncoder().encode(hashedBytes); Buffer data = Buffer.buffer(); data.appendString("HTTP/1.1 101 Switching Protocols\r\n"); data.appendString("Upgrade: websocket\r\n"); data.appendString("Connection: upgrade\r\n"); data.appendString("Sec-WebSocket-Accept: " + new String(accept) + "\r\n"); data.appendString("\r\n"); so.write(data); return so; } catch (NoSuchAlgorithmException e) { req.response().setStatusCode(500).end(); fail(e.getMessage()); return null; } }
private void testResponseCompression(boolean enabled) throws Exception { byte[] expected = TestUtils.randomAlphaString(1000).getBytes(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); GZIPOutputStream in = new GZIPOutputStream(baos); in.write(expected); in.close(); byte[] compressed = baos.toByteArray(); server.close(); server = vertx.createHttpServer(serverOptions); server.requestHandler(req -> { assertEquals(enabled ? "deflate, gzip" : null, req.getHeader(HttpHeaderNames.ACCEPT_ENCODING)); req.response().putHeader(HttpHeaderNames.CONTENT_ENCODING.toLowerCase(), "gzip").end(Buffer.buffer(compressed)); }); startServer(); client.close(); client = vertx.createHttpClient(clientOptions.setTryUseCompression(enabled)); client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onSuccess(resp -> { String encoding = resp.getHeader(HttpHeaderNames.CONTENT_ENCODING); assertEquals(enabled ? null : "gzip", encoding); resp.bodyHandler(buff -> { assertEquals(Buffer.buffer(enabled ? expected : compressed), buff); testComplete(); }); })).end(); 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 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(); }
} else { assertEquals(t, req.absoluteURI()); assertEquals("foo_value", req.getHeader("foo")); assertEquals(expectedMethod, req.method()); resp.end();
@Test public void testChunkedClientRequest() { server.requestHandler(req -> { HttpServerResponse resp = req.response(); assertEquals("chunked", req.getHeader("transfer-encoding")); req.bodyHandler(body -> { assertEquals("the-chunk", body.toString()); req.response().end(); }); }).listen(onSuccess(server -> { HttpClientRequest req = client.put(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", res -> { testComplete(); }); req.setChunked(true); req.write("the-chunk"); vertx.setTimer(1, id -> { req.end(); }); })); await(); }
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)) {
@Test public void testPerHostPooling() throws Exception { client.close(); client = vertx.createHttpClient(new HttpClientOptions() .setMaxPoolSize(1) .setKeepAlive(true) .setPipelining(false)); testPerXXXPooling((i, handler) -> client.get(DEFAULT_HTTP_PORT, "host" + i, "/somepath", handler).setHost("host:8080") .putHeader("key", "host" + i), req -> req.getHeader("key")); }
@Test public void test100ContinueHandledManually() throws Exception { server.close(); server = vertx.createHttpServer(createBaseServerOptions()); Buffer toSend = TestUtils.randomBuffer(1000); server.requestHandler(req -> { assertEquals("100-continue", req.getHeader("expect")); req.response().writeContinue(); req.bodyHandler(data -> { assertEquals(toSend, data); req.response().end(); }); }); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.endHandler(v -> testComplete()); })); req.headers().set("Expect", "100-continue"); req.setChunked(true); req.continueHandler(v -> { req.write(toSend); req.end(); }); req.sendHead(); })); await(); }
@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(); }
private void testServerMaxHeaderSize(int maxHeaderSize) { String longHeader = TestUtils.randomAlphaString(9000); vertx.createHttpServer(new HttpServerOptions().setMaxHeaderSize(maxHeaderSize) .setHost("localhost").setPort(8080)).requestHandler(req -> { assertEquals(req.getHeader("t"), longHeader); req.response().end(); }).listen(onSuccess(res -> { HttpClientRequest req = vertx.createHttpClient(new HttpClientOptions()) .request(HttpMethod.GET, 8080, "localhost", "/", onSuccess(resp -> { if (maxHeaderSize > HttpServerOptions.DEFAULT_MAX_HEADER_SIZE) { assertEquals(200, resp.statusCode()); testComplete(); } else { assertEquals(400, resp.statusCode()); resp.request().connection().closeHandler(v -> { testComplete(); }); } })); // Add longHeader req.putHeader("t", longHeader); 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(); }
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));
@Override public String getFormattedItem(AccessLogParam<RoutingContext> accessLogParam) { String traceId = getValueFromInvocationContext(accessLogParam); if (StringUtils.isEmpty(traceId)) { traceId = accessLogParam.getContextData().request().getHeader(TRACE_ID); } if (StringUtils.isEmpty(traceId)) { return InvocationContextItem.NOT_FOUND; } return traceId; } }