@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(); }
ContextInternal serverContext = ((VertxInternal) vertx).getContext(); if (serverRequestContext.get() != null) { assertSame(serverRequestContext.get(), serverContext); } else { serverRequestContext.set(serverContext); AtomicReference<ContextInternal> listenContext = new AtomicReference<>(); server.listen(ar -> { assertTrue(ar.succeeded()); listenContext.set(((VertxInternal) vertx).getContext()); latch.countDown(); }); awaitLatch(latch); CountDownLatch latch2 = new CountDownLatch(1); int numReqs = 16; client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(numConns)); for (int i = 0; i < numReqs; i++) { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> { assertEquals(200, resp.statusCode()); contexts.add(((VertxInternal) vertx).getContext()); if (cnt.incrementAndGet() == numReqs) { int size = contexts.size(); assertEquals(1, size); latch2.countDown(); awaitLatch(latch2);
@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 testHttpClientResponseDecodeError(Handler<Throwable> errorHandler) throws Exception { startServer(); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", onSuccess(resp -> { resp.exceptionHandler(errorHandler); })); await(); }
@Test public void testInvalidChunkInHttpServerRequest() throws Exception { testHttpServerRequestDecodeError(so -> { so.write("invalid\r\n"); // Empty chunk }, errors -> { assertEquals(2, errors.size()); assertEquals(NumberFormatException.class, errors.get(0).getClass()); }); }
@Test public void testSharedServersRoundRobinWithOtherServerRunningOnDifferentPort() throws Exception { // Have a server running on a different port to make sure it doesn't interact CountDownLatch latch = new CountDownLatch(1); HttpServer theServer = vertx.createHttpServer(new HttpServerOptions().setPort(8081)); theServer.requestHandler(req -> { fail("Should not process request"); }).listen(onSuccess(s -> latch.countDown())); awaitLatch(latch); testSharedServersRoundRobin(); }
assertEquals(NetworkOptions.DEFAULT_SEND_BUFFER_SIZE, options.getSendBufferSize()); int rand = TestUtils.randomPositiveInt(); assertEquals(options, options.setSendBufferSize(rand)); assertEquals(rand, options.getSendBufferSize()); assertIllegalArgumentException(() -> options.setSendBufferSize(0)); assertIllegalArgumentException(() -> options.setSendBufferSize(-123)); assertEquals(NetworkOptions.DEFAULT_RECEIVE_BUFFER_SIZE, options.getReceiveBufferSize()); rand = TestUtils.randomPositiveInt(); assertEquals(options, options.setReceiveBufferSize(rand)); assertEquals(rand, options.getReceiveBufferSize()); assertIllegalArgumentException(() -> options.setReceiveBufferSize(0)); assertIllegalArgumentException(() -> options.setReceiveBufferSize(-123)); assertTrue(options.isReuseAddress()); assertEquals(options, options.setReuseAddress(false)); assertFalse(options.isReuseAddress()); assertEquals(NetworkOptions.DEFAULT_TRAFFIC_CLASS, options.getTrafficClass()); rand = 23; assertEquals(options, options.setTrafficClass(rand)); assertEquals(rand, options.getTrafficClass()); assertIllegalArgumentException(() -> options.setTrafficClass(-2)); assertIllegalArgumentException(() -> options.setTrafficClass(256)); assertTrue(options.isTcpNoDelay()); assertEquals(options, options.setTcpNoDelay(false)); assertFalse(options.isTcpNoDelay());
@Test public void testDeferredRequestEnd() throws Exception { server.requestHandler(req -> { req.pause(); req.bodyHandler(body -> { assertTrue(req.isEnded()); req.response().end(body); }); vertx.setTimer(10, v -> { assertFalse(req.isEnded()); req.resume(); }); }); startServer(); Buffer expected = Buffer.buffer(TestUtils.randomAlphaString(1024)); client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/", onSuccess(resp -> { resp.bodyHandler(body -> { assertEquals(expected, body); testComplete(); }); })).end(expected); await(); }
private void testPerXXXPooling(BiFunction<Integer, Handler<AsyncResult<HttpClientResponse>>, HttpClientRequest> requestProvider, Function<HttpServerRequest, String> keyExtractor) throws Exception { waitFor(2); int numPeers = 3; int numRequests = 5; server.requestHandler(req -> { String key = keyExtractor.apply(req); assertFalse(map.containsKey(key)); map.put(key, req.response()); if (map.size() == numPeers) { map.clear(); if (count.incrementAndGet() == numRequests) { complete(); startServer(); AtomicInteger remaining = new AtomicInteger(numPeers * numRequests); for (int i = 0;i < numPeers;i++) { for (int j = 0;j < numRequests;j++) { HttpClientRequest req = requestProvider.apply(i, onSuccess(resp -> { assertEquals(200, resp.statusCode()); if (remaining.decrementAndGet() == 0) { complete(); await();
startServer(); client.close(); client = vertx.createHttpClient(createBaseClientOptions().setMaxPoolSize(2)); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", onSuccess(resp -> { resp.endHandler(v1 -> { awaitLatch(latch); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/someuri", onSuccess(resp -> { assertSame(resp.request().connection(), connections.get(1)); testComplete(); })); await();
private void testResetClientRequestNotYetSent(boolean keepAlive, boolean pipelined) throws Exception { waitFor(2); server.close(); NetServer server = vertx.createNetServer(); AtomicInteger numReq = new AtomicInteger(); server.connectHandler(conn -> { assertEquals(0, numReq.getAndIncrement()); StringBuilder sb = new StringBuilder(); conn.handler(buff -> { "Content-Length: 0\r\n" + "\r\n"); complete(); server.listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v -> { latch.countDown(); })); awaitLatch(latch); client.close(); client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setKeepAlive(keepAlive).setPipelining(pipelined)); HttpClientRequest post = client.post(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> { fail(); }); post.setChunked(true).write(TestUtils.randomBuffer(1024)); assertTrue(post.reset()); client.getNow(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> { assertEquals(1, numReq.get()); complete(); });
@Test public void testResetKeepAliveClientRequest() throws Exception { waitFor(3); server.close(); NetServer server = vertx.createNetServer(); AtomicInteger count = new AtomicInteger(); server.connectHandler(so -> { assertEquals(0, count.getAndIncrement()); Buffer total = Buffer.buffer(); so.handler(buff -> { "Hello world"); so.closeHandler(v -> { complete(); }); }); CountDownLatch listenLatch = new CountDownLatch(1); server.listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v -> { listenLatch.countDown(); })); awaitLatch(listenLatch); client.close(); client = vertx.createHttpClient(new HttpClientOptions().setMaxPoolSize(1).setPipelining(false).setKeepAlive(true)); AtomicInteger status = new AtomicInteger(); HttpClientRequest req1 = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", resp -> { assertEquals(0, status.getAndIncrement()); }); req1.connectionHandler(conn -> {
Context ctx = Vertx.currentContext(); if (context.get() != null) { assertSame(ctx, context.get()); } else { context.set(ctx); latchConns.countDown(); req.response().end(); }).listen(onSuccess(s -> { assertEquals(DEFAULT_HTTP_PORT, s.actualPort()); latchListen.countDown(); })); awaitLatch(latchListen); assertTrue(latchClient.await(10, TimeUnit.SECONDS)); assertTrue(latchConns.await(10, TimeUnit.SECONDS)); assertEquals(numServers, connectedServers.size()); for (HttpServer server : servers) { assertTrue(connectedServers.contains(server)); assertEquals(numServers, requestCount.size()); assertEquals(requestCount.values().stream().mapToInt(i -> i).sum(), numRequests); assertEquals(IntStream.range(0, requestCount.size()) .mapToObj(i -> numRequests / numServers) .collect(Collectors.toList()), new ArrayList<>(requestCount.values())); assertEquals(numServers, contexts.size());
server.close(); server = vertx .createHttpServer(createBaseServerOptions().setIdleTimeout(400).setIdleTimeoutUnit(TimeUnit.MILLISECONDS)) .requestHandler( req -> { req.response().sendFile(sent.getAbsolutePath()); }); startServer(); client.getNow(8080, "localhost", "/", onSuccess(resp -> { long now = System.currentTimeMillis(); int[] length = {0}; resp.exceptionHandler(this::fail); resp.endHandler(v -> { assertEquals(expected, length[0]); assertTrue(System.currentTimeMillis() - now > 1000); testComplete(); }); })); await();
client = vertx.createHttpClient(new HttpClientOptions().setKeepAlive(false).setMaxPoolSize(1)); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(t -> { assertTrue(t instanceof TimeoutException); })); req.setTimeout(500); HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { assertEquals(200, resp.statusCode()); testComplete(); })); req.exceptionHandler(t -> fail("Should not throw exception")); req.setTimeout(3000); req.end(); })); await();
assertEquals(sendBufferSize, options.getSendBufferSize()); assertEquals(receiverBufferSize, options.getReceiveBufferSize()); assertEquals(reuseAddress, options.isReuseAddress()); assertEquals(trafficClass, options.getTrafficClass()); assertEquals(tcpKeepAlive, options.isTcpKeepAlive()); assertEquals(tcpNoDelay, options.isTcpNoDelay()); assertEquals(soLinger, options.getSoLinger()); assertEquals(usePooledBuffers, options.isUsePooledBuffers()); assertEquals(idleTimeout, options.getIdleTimeout()); assertEquals(ssl, options.isSsl()); assertNotSame(keyStoreOptions, options.getKeyCertOptions()); assertEquals(ksPassword, ((JksOptions) options.getKeyCertOptions()).getPassword()); assertEquals(ksPath, ((JksOptions) options.getKeyCertOptions()).getPath()); assertNotSame(trustStoreOptions, options.getTrustOptions()); assertEquals(tsPassword, ((JksOptions) options.getTrustOptions()).getPassword()); assertEquals(tsPath, ((JksOptions) options.getTrustOptions()).getPath()); assertEquals(1, options.getEnabledCipherSuites().size()); assertTrue(options.getEnabledCipherSuites().contains(enabledCipher)); assertEquals(1, options.getCrlPaths().size()); assertEquals(crlPath, options.getCrlPaths().get(0)); assertEquals(port, options.getPort()); assertEquals(host, options.getHost()); assertEquals(acceptBacklog, options.getAcceptBacklog()); assertEquals(compressionSupported, options.isCompressionSupported()); assertEquals(maxWebsocketFrameSize, options.getMaxWebsocketFrameSize()); assertEquals(wsSubProtocol, options.getWebsocketSubProtocols()); assertEquals(is100ContinueHandledAutomatically, options.isHandle100ContinueAutomatically()); assertEquals(maxChunkSize, options.getMaxChunkSize()); assertEquals(maxInitialLineLength, options.getMaxInitialLineLength());
@Test public void testIncorrectHttpVersion() throws Exception { server.requestHandler(req -> { NetSocket so = req.netSocket(); so.write(Buffer.buffer("HTTP/1.2 200 OK\r\nContent-Length:5\r\n\r\nHELLO")); so.close(); }); startServer(); AtomicBoolean a = new AtomicBoolean(); HttpClientRequest req = client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onFailure(err -> { if (a.compareAndSet(false, true)) { assertTrue("message " + err.getMessage() + " should contain HTTP/1.2", err.getMessage().contains("HTTP/1.2")); } })); req.exceptionHandler(err -> { fail("Should not be called"); }).putHeader("connection", "close") .connectionHandler(conn -> conn.closeHandler(v -> testComplete())) .end(); await(); }
@Test public void testMaxWaitQueueSizeIsRespected() throws Exception { client.close(); client = vertx.createHttpClient(new HttpClientOptions().setDefaultHost(DEFAULT_HTTP_HOST).setDefaultPort(DEFAULT_HTTP_PORT) .setPipelining(false).setMaxWaitQueueSize(0).setMaxPoolSize(2)); waitFor(3); Set<String> expected = new HashSet<>(Arrays.asList("/1", "/2")); server.requestHandler(req -> { assertTrue(expected.contains(req.path())); complete(); }); startServer(); HttpClientRequest req1 = client.get("/1", onFailure(err -> { })); HttpClientRequest req2 = client.get("/2", onFailure(resp -> { })); HttpClientRequest req3 = client.get("/3", onFailure(t -> { assertTrue("Incorrect exception: " + t.getClass().getName(), t instanceof ConnectionPoolTooBusyException); complete(); })); req1.end(); req2.end(); req3.end(); await(); }
@Test public void testClosingVertxCloseSharedServers() throws Exception { int numServers = 2; Vertx vertx = Vertx.vertx(); List<HttpServerImpl> servers = new ArrayList<>(); for (int i = 0;i < numServers;i++) { HttpServer server = vertx.createHttpServer(createBaseServerOptions()).requestHandler(req -> { }); startServer(server); servers.add((HttpServerImpl) server); } CountDownLatch latch = new CountDownLatch(1); vertx.close(onSuccess(v -> { latch.countDown(); })); awaitLatch(latch); servers.forEach(server -> { assertTrue(server.isClosed()); }); }
@Test public void testHttpClientRequestShouldExceptionHandlerWhenTheClosedHandlerIsCalled() throws Exception { server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).requestHandler(req -> { vertx.setTimer(1000, id -> { req.response().close(); }); }); startServer(); HttpClientRequest req = client.put(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/someuri", resp -> { }).setChunked(true); CountDownLatch latch = new CountDownLatch(1); req.sendHead(version -> latch.countDown()); awaitLatch(latch); CheckingSender sender = new CheckingSender(vertx.getOrCreateContext(), req); req.exceptionHandler(err -> { Throwable failure = sender.close(); if (failure != null) { fail(failure); } else { testComplete(); } }); sender.send(); await(); }