req.headers().setAll(headers);
@Override public void start() throws Exception { HttpClientRequest req = vertx.createHttpClient(new HttpClientOptions()).put(8080, "localhost", "/someurl", resp -> { System.out.println("Response " + resp.statusCode()); }); String filename = "upload.txt"; FileSystem fs = vertx.fileSystem(); fs.props(filename, ares -> { FileProps props = ares.result(); System.out.println("props is " + props); long size = props.size(); req.headers().set("content-length", "" + size); fs.open(filename, new OpenOptions(), ares2 -> { AsyncFile file = ares2.result(); Pump pump = Pump.pump(file, req); file.endHandler(v -> { req.end(); }); pump.start(); }); }); } }
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 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(); }
@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); } }
private void testRequestBodyWrite(boolean chunked) { Buffer body = Buffer.buffer(); server.requestHandler(req -> { req.bodyHandler(buffer -> { assertEquals(body, buffer); req.response().end(); }); }); server.listen(onSuccess(server -> { HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> testComplete()); int numWrites = 10; int chunkSize = 100; if (chunked) { req.setChunked(true); } else { req.headers().set("Content-Length", String.valueOf(numWrites * chunkSize)); } for (int i = 0; i < numWrites; i++) { Buffer b = TestUtils.randomBuffer(chunkSize); body.appendBuffer(b); req.write(b); } req.end(); })); await(); }
private void testRequestBodyWriteString(boolean chunked, String encoding) { String body = TestUtils.randomUnicodeString(1000); Buffer bodyBuff; if (encoding == null) { bodyBuff = Buffer.buffer(body); } else { bodyBuff = Buffer.buffer(body, encoding); } server.requestHandler(req -> { req.bodyHandler(buff -> { assertEquals(bodyBuff, buff); testComplete(); }); }); server.listen(onSuccess(server -> { HttpClientRequest req = client.request(HttpMethod.POST, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, noOpHandler()); if (chunked) { req.setChunked(true); } else { req.headers().set("Content-Length", String.valueOf(bodyBuff.length())); } if (encoding == null) { req.write(body); } else { req.write(body, encoding); } req.end(); })); await(); }
fail("Should not throw exception: " + t.getMessage()); }); req.headers().set("count", String.valueOf(i)); req.end();
})); req.setChunked(true); req.headers().set("count", String.valueOf(count)); req.write("This is content " + count); req.end();
@Test public void testAccessNetSocket() throws Exception { Buffer toSend = TestUtils.randomBuffer(1000); server.requestHandler(req -> { req.response().headers().set("HTTP/1.1", "101 Upgrade"); req.bodyHandler(data -> { assertEquals(toSend, data); req.response().end("somecontent"); }); }); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.endHandler(v -> { assertNotNull(resp.netSocket()); testComplete(); }); })); req.headers().set("content-length", String.valueOf(toSend.length())); req.write(toSend); })); await(); }
@Test public void test100ContinueRejectedManually() throws Exception { server.close(); server = vertx.createHttpServer(createBaseServerOptions()); server.requestHandler(req -> { req.response().setStatusCode(405).end(); req.bodyHandler(data -> { fail("body should not be received"); }); }); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.PUT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(405, resp.statusCode()); testComplete(); })); req.headers().set("Expect", "100-continue"); req.setChunked(true); req.continueHandler(v -> { fail("should not be called"); }); req.sendHead(); })); await(); }
@Test public void test100ContinueHandledAutomatically() throws Exception { Buffer toSend = TestUtils.randomBuffer(1000); server.requestHandler(req -> { 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 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 testPreflightAllowedHeaders() throws Exception { Set<HttpMethod> allowedMethods = new LinkedHashSet<>(Arrays.asList(HttpMethod.PUT, HttpMethod.DELETE)); Set<String> allowedHeaders = new LinkedHashSet<>(Arrays.asList("X-wibble", "X-blah")); router.route().handler(CorsHandler.create("vertx\\.io").allowedMethods(allowedMethods).allowedHeaders(allowedHeaders)); router.route().handler(context -> context.response().end()); testRequest(HttpMethod.OPTIONS, "/", req -> { req.headers().add("origin", "vertx.io"); req.headers().add("access-control-request-method", "PUT,DELETE"); req.headers().add("access-control-request-headers", allowedHeaders); }, resp -> checkHeaders(resp, "vertx.io", "PUT,DELETE", "X-wibble,X-blah", null), 200, "OK", null); }
@Test public void testAcceptPatternDenied() throws Exception { // Any subdomains of vertx.io router.route().handler(CorsHandler.create(".*\\.vertx\\.io")); router.route().handler(context -> context.response().end()); testRequest(HttpMethod.GET, "/", req -> req.headers().add("origin", "foo.vertx.com"), resp -> checkHeaders(resp, null, null, null, null), 403, "CORS Rejected - Invalid origin", null); testRequest(HttpMethod.GET, "/", req -> req.headers().add("origin", "barxvertxxio"), resp -> checkHeaders(resp, null, null, null, null), 403, "CORS Rejected - Invalid origin", null); }