Refine search
/** * test socks4a proxy for accessing arbitrary server port. */ @Test public void testWithSocks4aProxy() 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); proxy.start(vertx); server.listen(1234, "localhost", ar -> { assertTrue(ar.succeeded()); client.connect(1234, "localhost", ar2 -> { if (ar2.failed()) { log.warn("failed", ar2.cause()); } assertTrue(ar2.succeeded()); // make sure we have gone through the proxy assertEquals("localhost:1234", proxy.getLastUri()); testComplete(); }); }); 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());
@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()); } }); } }
static void fromJson(Iterable<java.util.Map.Entry<String, Object>> json, NetClientOptions obj) { for (java.util.Map.Entry<String, Object> member : json) { switch (member.getKey()) { case "hostnameVerificationAlgorithm": if (member.getValue() instanceof String) { obj.setHostnameVerificationAlgorithm((String)member.getValue()); } break; case "reconnectAttempts": if (member.getValue() instanceof Number) { obj.setReconnectAttempts(((Number)member.getValue()).intValue()); } break; case "reconnectInterval": if (member.getValue() instanceof Number) { obj.setReconnectInterval(((Number)member.getValue()).longValue()); } break; } } }
@Test public final void testAdd() { NetClientOptions options = new NetClientOptions(new JsonObject("{}")); options.addEnabledCipherSuite("XXX"); }
@Test public void testTLSHostnameCertCheckCorrect() { 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, "localhost", arSocket -> { if (arSocket.succeeded()) { NetSocket ns = arSocket.result(); ns.exceptionHandler(th -> { fail(th); }); ns.upgradeToSsl(v -> { testComplete(); }); } else { fail(ar.cause()); } }); }); await(); }
private void waitPortToClose(Handler<AsyncResult<Void>> stopFuture, int iter) { if (port > 0) { // fail if port is already in use NetClientOptions options = new NetClientOptions().setConnectTimeout(50); NetClient c = vertx.createNetClient(options); c.connect(port, "localhost", res -> { if (res.succeeded()) { NetSocket socket = res.result(); socket.close(); if (iter > 0) { vertx.setTimer(100, x -> waitPortToClose(stopFuture, iter - 1)); } else { stopFuture.handle(Future.failedFuture(messages.getMessage("11503", Integer.toString(port)))); } } else { stopFuture.handle(Future.succeededFuture()); } }); } else { stopFuture.handle(Future.succeededFuture()); } }
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 CompletableFuture<Result> check() { VertxCompletableFuture<Result> result = new VertxCompletableFuture<>(vertx); NetClientOptions options = new NetClientOptions().setConnectTimeout(500); NetClient client = vertx.createNetClient(options); client.connect(port, host, res -> { if (res.succeeded()) { result.complete(Result.healthy()); } else { result.complete(Result.unhealthy(res.cause())); } client.close(); }); return result; } }
@Test public void testHostVerificationHttpsMatching() { server.close(); NetServerOptions options = new NetServerOptions() .setPort(1234) .setHost("localhost") .setSsl(true) .setKeyStoreOptions(new JksOptions().setPath("tls/server-keystore.jks").setPassword("wibble")); NetServer server = vertx.createNetServer(options); NetClientOptions clientOptions = new NetClientOptions() .setSsl(true) .setTrustAll(true) .setHostnameVerificationAlgorithm("HTTPS"); NetClient client = vertx.createNetClient(clientOptions); server.connectHandler(sock -> { }); server.listen(ar -> { assertTrue(ar.succeeded()); client.connect(1234, "localhost", ar2 -> { //Should be able to connect assertTrue(ar2.succeeded()); testComplete(); }); }); await(); }
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()) {
X509Certificate[] certs = socket.peerCertificateChain(); if (clientCert != Cert.NONE) { assertNotNull(certs); server = vertx.createNetServer(options); if (!shouldPass) { waitForMore(1); server.connectHandler(serverHandler).listen(address, ar -> { assertTrue(ar.succeeded()); client.close(); NetClientOptions clientOptions = new NetClientOptions(); if (!startTLS) { clientOptions.setSsl(true); clientOptions.setTrustAll(true); clientOptions.setTrustOptions(clientTrust.get()); clientOptions.setKeyCertOptions(clientCert.get()); for (String suite: enabledCipherSuites) { clientOptions.addEnabledCipherSuite(suite); clientOptions.getEnabledSecureTransportProtocols().forEach(clientOptions::removeEnabledSecureTransportProtocol); clientOptions.addEnabledSecureTransportProtocol(protocol); final NetSocket socket = ar2.result();
RabbitMQOptions config = super.config(); ConnectionFactory cf = new ConnectionFactory(); NetClientOptions clientOptions = new NetClientOptions(); if (config.getUri() != null) { cf.setUri(config.getUri()); if (cf.isSSL()) { clientOptions.setSsl(true); clientOptions.setTrustAll(true); proxyClient = vertx.createNetClient(clientOptions); AtomicInteger remaining = new AtomicInteger(numDisconnects); proxyServer = vertx.createNetServer().connectHandler(serverSocket -> { if (remaining.getAndDecrement() > 0) { serverSocket.close(); } else { serverSocket.pause(); proxyClient.connect(port, host, ar -> { if (ar.succeeded()) { NetSocket clientSocket = ar.result(); serverSocket.handler(clientSocket::write); serverSocket.exceptionHandler(err -> serverSocket.close()); serverSocket.closeHandler(v -> clientSocket.close()); }).listen(PROXY_PORT, "localhost", ar -> { if (ar.succeeded()) { latch.complete(null); } else {
@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 -> {
@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 testSendVoidMessage(TestContext context) { // Send a request and get a response NetClient client = vertx.createNetClient(new NetClientOptions().setSsl(true).setTrustAll(true) .setKeyStoreOptions(new JksOptions().setPath("client.keystore").setPassword("wibble"))); final Async async = context.async(); vertx.eventBus().consumer("test", (Message<JsonObject> msg) -> { client.close(); async.complete(); }); client.connect(7000, "localhost", conn -> { context.assertFalse(conn.failed()); NetSocket socket = conn.result(); FrameHelper.sendFrame("send", "test", new JsonObject().put("value", "vert.x"), socket); }); }
private Future<UUID> connectTcpEndpoint(final UUID sid, final String host, final int port, final String clienthost) { final Future<UUID> future = Future.future(); final NetClient client = vertx.createNetClient(new NetClientOptions().setReconnectAttempts(10).setReconnectInterval(500)); client.connect(port, host, asyncResult -> { if (asyncResult.succeeded()) { logger.info("Connected to ssh server: " + host + ":" + port + " (" + clienthost + ")"); QueueFactory.createQueue(sid.toString()); asyncResult.result().drainHandler(v -> asyncResult.result().resume()); asyncResult.result().handler(buffer -> { try { final TransferQueue queue = QueueFactory.getQueue(sid.toString());
CountDownLatch latchConns = new CountDownLatch(numConnections); for (int i = 0; i < numServers; i++) { NetServer theServer = vertx.createNetServer(); servers.add(theServer); theServer.connectHandler(sock -> { connectCount.compute(theServer, (s, cur) -> cur == null ? 1 : cur + 1); latchConns.countDown(); }).listen(testAddress, ar -> { if (ar.succeeded()) { latchListen.countDown(); } else { client.close(); client = vertx.createNetClient(new NetClientOptions()); CountDownLatch latchClient = new CountDownLatch(numConnections); for (int i = 0; i < numConnections; i++) { client.connect(testAddress, res -> { if (res.succeeded()) { latchClient.countDown(); } else { res.cause().printStackTrace(); fail("Failed to connect");
@Test public void testNettyServerUsesContextEventLoop() throws Exception { ContextInternal context = (ContextInternal) vertx.getOrCreateContext(); AtomicReference<Thread> contextThread = new AtomicReference<>(); CountDownLatch latch = new CountDownLatch(1); try { fut.sync(); vertx.createNetClient(new NetClientOptions()).connect(1234, "localhost", ar -> { assertTrue(ar.succeeded()); NetSocket so = ar.result(); so.write(Buffer.buffer("hello")); }); await();
@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(); }