@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 testClientOptionsCopiedBeforeUse() { client.close(); server.requestHandler(req -> { req.response().end(); }); server.listen(ar -> { assertTrue(ar.succeeded()); HttpClientOptions options = new HttpClientOptions(); client = vertx.createHttpClient(options); // Now change something - but server should ignore this options.setSsl(true); client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/uri", onSuccess(res -> { assertEquals(200, res.statusCode()); testComplete(); })).end(); }); await(); }
@Test public void testDisableIdleTimeoutClearTextUpgrade() throws Exception { server.close(); server = vertx.createHttpServer(new HttpServerOptions() .setPort(8080) .setHost("localhost")); server.requestHandler(req -> { req.response().end(); }); startServer(); client.close(); client = vertx.createHttpClient(new HttpClientOptions() .setIdleTimeout(2) .setProtocolVersion(HttpVersion.HTTP_2) .setDefaultPort(8080) .setDefaultHost("localhost")); client.get("/somepath", onSuccess(resp1 -> { resp1.exceptionHandler(this::fail); resp1.endHandler(v1 -> { vertx.setTimer(10, id1 -> { client.get("/somepath", onSuccess(resp2 -> { resp2.exceptionHandler(this::fail); resp2.endHandler(v2 -> { testComplete();
@Override public void start() throws Exception { // Note! in real-life you wouldn't often set trust all to true as it could leave you open to man in the middle attacks. vertx.createHttpClient(new HttpClientOptions().setSsl(true).setTrustAll(true)).getNow(4443, "localhost", "/", resp -> { System.out.println("Got response " + resp.statusCode()); resp.bodyHandler(body -> System.out.println("Got data " + body.toString("ISO-8859-1"))); }); } }
@Override public void start() throws Exception { // Note! in real-life you wouldn't often set trust all to true as it could leave you open to man in the middle attacks. HttpClientOptions options = new HttpClientOptions(). setSsl(true). setUseAlpn(true). setProtocolVersion(HttpVersion.HTTP_2). setTrustAll(true); vertx.createHttpClient(options ).getNow(8443, "localhost", "/", resp -> { System.out.println("Got response " + resp.statusCode() + " with protocol " + resp.version()); resp.bodyHandler(body -> System.out.println("Got data " + body.toString("ISO-8859-1"))); }); } }
static HttpClientOptions createHttp2ClientOptions() { return new HttpClientOptions(). setUseAlpn(true). setSsl(true). setTrustStoreOptions(Trust.SERVER_JKS.get()). setProtocolVersion(HttpVersion.HTTP_2); }
@Test public void testHttpSocksProxyRequest() throws Exception { startProxy(null, ProxyType.SOCKS5); client.close(); client = vertx.createHttpClient(new HttpClientOptions() .setProxyOptions(new ProxyOptions().setType(ProxyType.SOCKS5).setHost("localhost").setPort(proxy.getPort()))); server.requestHandler(req -> { req.response().end(); }); server.listen(onSuccess(s -> { client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> { assertEquals(200, resp.statusCode()); assertNotNull("request did not go through proxy", proxy.getLastUri()); testComplete(); })).exceptionHandler(th -> fail(th)).end(); })); await(); }
private void doTest(SSLEngineOptions engine, boolean useAlpn, HttpVersion version, String error, String expectedSslContext, boolean expectCause) { server.close(); HttpServerOptions options = new HttpServerOptions() .setSslEngineOptions(engine) .setUseAlpn(useAlpn); try { server = vertx.createHttpServer(options); } catch (VertxException e) { e.printStackTrace(); break; client = vertx.createHttpClient(new HttpClientOptions() .setSslEngineOptions(engine) .setSsl(true) .setUseAlpn(useAlpn) .setTrustAll(true) .setProtocolVersion(version)); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { assertEquals(200, resp.statusCode()); testComplete(); }));
@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 testWebsocketAbs() { SelfSignedCertificate certificate = SelfSignedCertificate.create(); HttpServerOptions serverOptions = new HttpServerOptions().setPort(HttpTestBase.DEFAULT_HTTPS_PORT) .setSsl(true) .setKeyCertOptions(certificate.keyCertOptions()); HttpClientOptions clientOptions = new HttpClientOptions() .setTrustAll(true) .setVerifyHost(false); client = vertx.createHttpClient(clientOptions); server = vertx.createHttpServer(serverOptions).requestHandler(request -> { if ("/test".equals(request.path())) { request.upgrade().close(); } else { request.response().end(); } }).listen(onSuccess(server -> { String url = "wss://" + clientOptions.getDefaultHost() + ":" + HttpTestBase.DEFAULT_HTTPS_PORT + "/test"; client.websocketAbs(url, null, null, null, ws -> { ws.closeHandler(v -> { testComplete(); }); }, null); })); 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()); resp.bodyHandler(body -> { testComplete(); });
@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 testDumpManyRequestsOnQueue() throws Exception { int sendRequests = 10000; AtomicInteger receivedRequests = new AtomicInteger(); vertx.createHttpServer(createBaseServerOptions()).requestHandler(r-> { r.response().end(); if (receivedRequests.incrementAndGet() == sendRequests) { testComplete(); } }).listen(onSuccess(s -> { HttpClientOptions ops = createBaseClientOptions() .setDefaultPort(DEFAULT_HTTP_PORT) .setPipelining(true) .setKeepAlive(true); HttpClient client = vertx.createHttpClient(ops); IntStream.range(0, sendRequests).forEach(x -> client.getNow("/", r -> {})); })); await(); }
AtomicInteger server1Count = new AtomicInteger(); AtomicInteger server2Count = new AtomicInteger(); server.requestHandler(req -> { server1Count.incrementAndGet(); req.response().end(); }).listen(8080, onSuccess(s -> { latch1.countDown(); })); HttpServer server2 = vertx.createHttpServer().requestHandler(req -> { server2Count.incrementAndGet(); req.response().end(); }).listen(8080, onSuccess(s -> { latch1.countDown(); })); awaitLatch(latch1); HttpClient client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(false).setDefaultPort(8080)); client.getNow("/", onSuccess(resp -> { assertEquals(200, resp.statusCode()); latch2.countDown(); })); client.getNow("/", onSuccess(resp -> { assertEquals(200, resp.statusCode()); latch2.countDown(); }));
@Test public void testEndServerResponseResumeTheConnection() throws Exception { server.requestHandler(req -> { req.endHandler(v -> { req.pause(); req.response().end(); }); }); startServer(); client.close(); waitFor(2); client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(true).setMaxPoolSize(1)); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(200, resp.statusCode()); complete(); })); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(200, resp.statusCode()); complete(); })); await(); }
@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(); } }
@Test public void testMultipleRecursiveCallsAndPipelining() throws Exception { int sendRequests = 100; AtomicInteger receivedRequests = new AtomicInteger(); server.requestHandler(x -> { x.response().end("hello"); }) .listen(8080, r -> { if (r.succeeded()) { HttpClient client = vertx.createHttpClient(new HttpClientOptions() .setKeepAlive(true) .setPipelining(true) .setDefaultPort(8080) ); IntStream.range(0, 5).forEach(i -> recursiveCall(client, receivedRequests, sendRequests)); } }); await(); }
server.close(); HttpClientOptions options = new HttpClientOptions(); options.setProtocolVersion(version); options.setSsl(clientSSL); options.setForceSni(clientForceSNI); if (clientTrustAll) { options.setTrustAll(true); options.addCrlPath("tls/root-ca/crl.pem"); options.setOpenSslEngineOptions(new OpenSSLEngineOptions()); options.setUseAlpn(true); options.setVerifyHost(clientVerifyHost); options.setTrustOptions(clientTrust); options.setKeyCertOptions(clientCert); for (String suite: clientEnabledCipherSuites) { options.addEnabledCipherSuite(suite); options.getEnabledSecureTransportProtocols().forEach(options::removeEnabledSecureTransportProtocol); options.addEnabledSecureTransportProtocol(protocol); proxyOptions.setUsername("username").setPassword("username"); options.setProxyOptions(proxyOptions);
@Test public void testKeepAliveTimeout() throws Exception { server.requestHandler(req -> { req.response().end(); }); testKeepAliveTimeout(new HttpClientOptions().setMaxPoolSize(1).setKeepAliveTimeout(3), 1); }
private void testHttpClientResponsePause(Handler<HttpClientResponse> h) throws Exception { server.requestHandler(req -> req.response().end("ok")); startServer(); client.close(); client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setKeepAlive(true)); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp1 -> { h.handle(resp1); vertx.setTimer(10, timerId -> { // The connection should be resumed as it's ended client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp2 -> { assertSame(resp1.request().connection(), resp2.request().connection()); resp2.endHandler(v -> testComplete()); })); }); })); await(); }