Refine search
@Test public void testTLSHostnameCertCheckIncorrect() { server.close(); server = vertx.createNetServer(new NetServerOptions().setSsl(true).setPort(4043) .setKeyCertOptions(Cert.SERVER_JKS_ROOT_CA.get())); server.connectHandler(netSocket -> netSocket.close()).listen(ar -> { NetClientOptions options = new NetClientOptions() .setHostnameVerificationAlgorithm("HTTPS") .setTrustOptions(Trust.SERVER_JKS_ROOT_CA.get()); NetClient client = vertx.createNetClient(options); client.connect(4043, "127.0.0.1", arSocket -> { if (arSocket.succeeded()) { NetSocket ns = arSocket.result(); ns.closeHandler(v -> { testComplete(); }); ns.upgradeToSsl(v -> { fail("this test should fail"); }); } else { fail(ar.cause()); } }); }); await(); }
@Test public void testClientIdleTimeout() { client.close(); NetClientOptions netClientOptions = new NetClientOptions(); netClientOptions.setIdleTimeout(1000); netClientOptions.setIdleTimeoutUnit(TimeUnit.MILLISECONDS); client = vertx.createNetClient(netClientOptions); server.connectHandler(s -> { }).listen(testAddress, ar -> { assertTrue(ar.succeeded()); client.connect(testAddress, res -> { assertTrue(res.succeeded()); NetSocket socket = res.result(); socket.closeHandler(v -> testComplete()); }); }); await(); }
@Test public void testDummyNetClientMetrics() { NetClient client = vertx.createNetClient(new NetClientOptions()); assertFalse(client.isMetricsEnabled()); }
@Test public void testReconnectAttemptsNotEnough() { client.close(); client = vertx.createNetClient(new NetClientOptions().setReconnectAttempts(100).setReconnectInterval(10)); client.connect(testAddress, (res) -> { assertFalse(res.succeeded()); assertTrue(res.failed()); testComplete(); }); await(); }
/** * test socks4a proxy for accessing arbitrary server port using an already resolved address. */ @Test public void testWithSocks4LocalResolver() throws Exception { NetClientOptions clientOptions = new NetClientOptions() .setProxyOptions(new ProxyOptions().setType(ProxyType.SOCKS4).setPort(11080)); NetClient client = vertx.createNetClient(clientOptions); server.connectHandler(sock -> { }); proxy = new Socks4Proxy(null).start(vertx); server.listen(1234, "localhost", ar -> { assertTrue(ar.succeeded()); client.connect(1234, "127.0.0.1", ar2 -> { if (ar2.failed()) { log.warn("failed", ar2.cause()); } assertTrue(ar2.succeeded()); // make sure we have gone through the proxy assertEquals("127.0.0.1:1234", proxy.getLastUri()); testComplete(); }); }); await(); }
NetServerOptions options = new NetServerOptions(); options.setHost("localhost").setPort(PORT); server = vertx.createNetServer(options); server.connectHandler(socket -> { socket.handler(buffer -> { if (!buffer.getBuffer(0, clientRequest.length()).equals(clientRequest)) { throw new IllegalStateException("expected " + toHex(clientRequest) + ", got " + toHex(buffer)); log.debug("auth failed"); log.debug("writing: " + toHex(errorResponse)); socket.write(errorResponse); socket.close(); } else { String host; NetClient netClient = vertx.createNetClient(new NetClientOptions()); netClient.connect(port, host, result -> { if (result.succeeded()) { NetSocket clientSocket = result.result(); Pump.pump(clientSocket, socket).start(); } else { log.error("exception", result.cause()); }); CompletableFuture<Void> fut = new CompletableFuture<>(); server.listen(ar -> {
@Override public void start() throws Exception { NetClientOptions options = new NetClientOptions().setSsl(true).setTrustAll(true); vertx.createNetClient(options).connect(1234, "localhost", res -> { if (res.succeeded()) { NetSocket sock = res.result(); sock.handler(buff -> { System.out.println("client receiving " + buff.toString("UTF-8")); }); // Now send some data for (int i = 0; i < 10; i++) { String str = "hello " + i + "\n"; System.out.println("Net client sending: " + str); sock.write(str); } } else { System.out.println("Failed to connect " + res.cause()); } }); } }
@Test public void testWriteSameBufferMoreThanOnce() throws Exception { server.connectHandler(socket -> { Buffer received = Buffer.buffer(); socket.handler(buff -> { received.appendBuffer(buff); if (received.toString().equals("foofoo")) { testComplete(); } }); }).listen(testAddress, ar -> { assertTrue(ar.succeeded()); client.connect(testAddress, result -> { NetSocket socket = result.result(); Buffer buff = Buffer.buffer("foo"); socket.write(buff); socket.write(buff); }); }); await(); }
@Override public void start() throws Exception { vertx.createNetClient().connect(1234, "localhost", res -> { if (res.succeeded()) { NetSocket socket = res.result(); RecordParser parser = RecordParser.newDelimited("\n", socket); FlowableHelper.toFlowable(parser) .map(buffer -> buffer.toString("UTF-8")) .subscribe(greeting -> System.out.println("Net client receiving: " + greeting), t -> { t.printStackTrace(); socket.close(); }, socket::close); // Now send some data Stream.of("John", "Joe", "Lisa", "Bill").forEach(name -> { System.out.println("Net client sending: " + name); socket.write(name).write("\n"); }); } else { System.out.println("Failed to connect " + res.cause()); } }); } }
@Override public void start() throws Exception { vertx.createNetClient().connect(1234, "localhost", res -> { if (res.succeeded()) { NetSocket socket = res.result(); socket.handler(buffer -> { System.out.println("Net client receiving: " + buffer.toString("UTF-8")); }); // Now send some data for (int i = 0; i < 10; i++) { String str = "hello " + i + "\n"; System.out.println("Net client sending: " + str); socket.write(str); } } else { System.out.println("Failed to connect " + res.cause()); } }); } }
HttpServerOptions options = new HttpServerOptions(); options.setHost("localhost").setPort(PORT); server = vertx.createHttpServer(options); server.requestHandler(request -> { HttpMethod method = request.method(); return; NetClientOptions netOptions = new NetClientOptions(); NetClient netClient = vertx.createNetClient(netOptions); netClient.connect(port, host, result -> { if (result.succeeded()) { NetSocket serverSocket = request.netSocket(); NetSocket clientSocket = result.result(); serverSocket.closeHandler(v -> clientSocket.close()); clientSocket.closeHandler(v -> serverSocket.close()); Pump.pump(serverSocket, clientSocket).start(); Pump.pump(clientSocket, serverSocket).start(); uri = forceUri; HttpClient client = vertx.createHttpClient(); HttpClientRequest clientRequest = client.getAbs(uri, ar -> { if (ar.succeeded()) { HttpClientResponse resp = ar.result(); for (String name : resp.headers().names()) {
synchronized void connect() { if (connected) { throw new IllegalStateException("Already connected"); } client.connect(serverID.port, serverID.host, res -> { if (res.succeeded()) { connected(res.result()); } else { log.warn("Connecting to server " + serverID + " failed", res.cause()); close(); } }); }
}); startServer(); NetClient client = vertx.createNetClient(); try { CompletableFuture<MultiMap> result = new CompletableFuture<>(); client.connect(DEFAULT_HTTP_PORT, DEFAULT_HTTPS_HOST, ar -> { if (ar.succeeded()) { NetSocket so = ar.result(); so.write( method.name() + " / HTTP/1.1\r\n" + "Connection: close\r\n" + "\r\n"); Buffer body = Buffer.buffer(); so.exceptionHandler(result::completeExceptionally); so.handler(body::appendBuffer); so.endHandler(v -> { String content = body.toString(); result.completeExceptionally(ar.cause()); client.close();
@Test public void testConnectInvalidPort() { assertIllegalArgumentException(() -> client.connect(-1, "localhost", res -> {})); assertIllegalArgumentException(() -> client.connect(65536, "localhost", res -> {})); client.connect(9998, "localhost", res -> { assertTrue(res.failed()); assertFalse(res.succeeded()); assertNotNull(res.cause()); testComplete(); }); await(); }
CompletableFuture<Void> test1 = new CompletableFuture<>(); vertx.resolveAddress("localhost", ar -> { if (ar.succeeded()) { InetAddress resolved = ar.result(); if (resolved.equals(localhost)) { test1.complete(null); test1.completeExceptionally(ar.cause()); NetServer server = vertx.createNetServer(new NetServerOptions().setPort(1234).setHost(localhost.getHostAddress())); try { server.connectHandler(so -> { so.write("hello").end(); }); server.listen(ar -> { if (ar.succeeded()) { test3.complete(null); client.connect(1234, "localhost", ar -> { if (ar.succeeded()) { test4.complete(null); test4.get(10, TimeUnit.SECONDS); } finally { server.close();
ExecutorService exec = Executors.newFixedThreadPool(1); try { server.connectHandler(so -> { so.handler(buff -> { assertEquals(256, buff.length()); CountDownLatch latch = new CountDownLatch(1); exec.execute(() -> { latch.countDown(); so.write(expected); }); try { AtomicInteger done = new AtomicInteger(); for (int i = 0;i < num;i++) { client.connect(testAddress, ar -> { if (ar.succeeded()) { NetSocket so = ar.result(); so.handler(buff -> { assertEquals(expected, buff); so.close(); so.write(TestUtils.randomBuffer(256)); } else { ar.cause().printStackTrace();
@Override public void start() throws Exception { NetClient client = vertx.createNetClient(new NetClientOptions()); vertx.createHttpServer().requestHandler(req -> { if (req.method() == HttpMethod.CONNECT) { client.connect(port, host, ar -> { if (ar.succeeded()) { System.out.println("Connected to proxy"); NetSocket clientSocket = req.netSocket(); clientSocket.write("HTTP/1.0 200 Connection established\n\n"); NetSocket serverSocket = ar.result(); serverSocket.handler(buff -> { System.out.println("Forwarding server packet to the client"); clientSocket.write(buff); }); serverSocket.closeHandler(v -> {
CountDownLatch latch1 = new CountDownLatch(workers.size() - 1); workers.get(0).runOnContext(v -> { NetServer server = vertx.createNetServer(); server.connectHandler(so -> { so.handler(buf -> { assertEquals("hello", buf.toString()); testComplete(); }); }); server.listen(testAddress, ar -> { assertTrue(ar.succeeded()); }); awaitLatch(latch1); NetClient client = vertx.createNetClient(); client.connect(testAddress, ar -> { assertTrue(ar.succeeded()); NetSocket so = ar.result(); so.write(Buffer.buffer("hello")); }); await();
@Test public void testReadStreamPauseResume() { String path = "/some/path"; this.server = vertx.createHttpServer(new HttpServerOptions().setAcceptBacklog(10).setPort(HttpTestBase.DEFAULT_HTTP_PORT)); ReadStream<HttpServerRequest> httpStream = server.requestStream(); AtomicBoolean paused = new AtomicBoolean(); }); server.listen(listenAR -> { assertTrue(listenAR.succeeded()); paused.set(true); httpStream.pause(); netClient = vertx.createNetClient(new NetClientOptions().setConnectTimeout(1000)); netClient.connect(HttpTestBase.DEFAULT_HTTP_PORT, "localhost", socketAR -> { assertTrue(socketAR.succeeded()); NetSocket socket = socketAR.result(); Buffer buffer = Buffer.buffer(); socket.handler(buffer::appendBuffer); socket.closeHandler(v -> { assertEquals(0, buffer.length()); paused.set(false); httpStream.resume(); client = vertx.createHttpClient(new HttpClientOptions()); client.request(HttpMethod.GET, HttpTestBase.DEFAULT_HTTP_PORT, "localhost", path, onSuccess(resp -> { assertEquals(200, resp.statusCode());