void setHandlers(NetSocket sock) { Handler<Message<Buffer>> resumeHandler = m -> sock.resume(); MessageConsumer reg = vertx.eventBus().<Buffer>consumer("client_resume").handler(resumeHandler); sock.closeHandler(v -> reg.unregister()); }
@Test public void testWriteHandlerSuccess() throws Exception { CompletableFuture<Void> close = new CompletableFuture<>(); server.connectHandler(socket -> { socket.pause(); close.thenAccept(v -> { socket.resume(); }); }); startServer(); client.connect(testAddress, onSuccess(so -> { writeUntilFull(so, v -> { so.write(Buffer.buffer("lost buffer"), onSuccess(ack -> testComplete())); close.complete(null); }); })); await(); }
assertEquals(Buffer.buffer(), received); closed.set(true); so.resume(); }); so.endHandler(v -> {
void pausingServer(Handler<AsyncResult<NetServer>> listenHandler) { server.connectHandler(sock -> { sock.pause(); Handler<Message<Buffer>> resumeHandler = (m) -> sock.resume(); MessageConsumer reg = vertx.eventBus().<Buffer>consumer("server_resume").handler(resumeHandler); sock.closeHandler(v -> reg.unregister()); }).listen(testAddress, listenHandler); }
private void testAccessNetSocketPendingResponseData(boolean pause) { server.requestHandler(req -> { NetSocket so = req.netSocket(); so.write("hello"); }); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.CONNECT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { NetSocket so = resp.netSocket(); assertNotNull(so); so.handler(buff -> { // With HTTP/1.1 the buffer is received immediately but delivered asynchronously assertEquals("hello", buff.toString()); testComplete(); }); if (pause) { so.pause(); vertx.setTimer(100, id -> { so.resume(); }); } })); req.sendHead(); })); await(); }
so.pause(); vertx.setTimer(1, id -> { so.resume(); }); });
public io.vertx.rxjava.core.net.NetSocket resume() { delegate.resume(); return this; }
public io.vertx.rxjava.core.net.NetSocket resume() { delegate.resume(); return this; }
@Test public void testWriteHandlerSuccess() throws Exception { CompletableFuture<Void> close = new CompletableFuture<>(); server.connectHandler(socket -> { socket.pause(); close.thenAccept(v -> { socket.resume(); }); }); startServer(); client.connect(testAddress, onSuccess(so -> { writeUntilFull(so, v -> { so.write(Buffer.buffer("lost buffer"), onSuccess(ack -> testComplete())); close.complete(null); }); })); await(); }
void setHandlers(NetSocket sock) { Handler<Message<Buffer>> resumeHandler = m -> sock.resume(); MessageConsumer reg = vertx.eventBus().<Buffer>consumer("client_resume").handler(resumeHandler); sock.closeHandler(v -> reg.unregister()); }
assertEquals(Buffer.buffer(), received); closed.set(true); so.resume(); }); so.endHandler(v -> {
void pausingServer(Handler<AsyncResult<NetServer>> listenHandler) { server.connectHandler(sock -> { sock.pause(); Handler<Message<Buffer>> resumeHandler = (m) -> sock.resume(); MessageConsumer reg = vertx.eventBus().<Buffer>consumer("server_resume").handler(resumeHandler); sock.closeHandler(v -> reg.unregister()); }).listen(testAddress, listenHandler); }
private void testAccessNetSocketPendingResponseData(boolean pause) { server.requestHandler(req -> { NetSocket so = req.netSocket(); so.write("hello"); }); server.listen(onSuccess(s -> { HttpClientRequest req = client.request(HttpMethod.CONNECT, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, resp -> { NetSocket so = resp.netSocket(); assertNotNull(so); so.handler(buff -> { // With HTTP/1.1 the buffer is received immediately but delivered asynchronously assertEquals("hello", buff.toString()); testComplete(); }); if (pause) { so.pause(); vertx.setTimer(100, id -> { so.resume(); }); } }); req.sendHead(); })); await(); }
private void processSaslAuthentication() { if (authenticator == null) { return; } socket.pause(); authenticator.process(complete -> { if(complete) { authenticator = null; } socket.resume(); }); }
so.pause(); vertx.setTimer(1, id -> { so.resume(); }); });
void connect() { clientSocket.handler(buff -> serverSocket.write(serverSocketFilter.apply(buff))); serverSocket.handler(buff -> clientSocket.write(clientSocketFilter.apply(buff))); clientSocket.closeHandler(v -> serverSocket.close()); serverSocket.closeHandler(v -> clientSocket.close()); serverSocket.resume(); clientSocket.resume(); }
public RecordParser initialHandhakeProtocolParser() { NetSocket sock = netSocket; final RecordParser parser = RecordParser.newDelimited("\n", h -> { String cmd = h.toString(); if("START SESSION".equalsIgnoreCase(cmd)) { sock.pause(); start(); logger.info("Bridge Server - start session with " + "tenant: " + getTenant() + ", ip: " + sock.remoteAddress() + ", bridgeUUID: " + getBridgeUUID() ); sock.resume(); } else { String tenant = cmd; String tenantFromCert = new CertInfo(sock).getTenant(); if(tenantFromCert != null) tenant = tenantFromCert; setTenant(tenant); } }); return parser; } }
netSocket.resume(); } else { connected = false;
public void start() { init(); netSocket.pause(); consumer.pause(); // from remote tcp to local bus fromRemoteTcpToLocalBus.start(); // from local bus to remote tcp consumer.handler(bufferMessage -> { boolean isBridged = isBridged(bufferMessage); if (!isBridged) { boolean tenantMatch = tenantMatch(bufferMessage); if(tenantMatch) { netSocketWrapper.sendMessageToClient(bufferMessage.body()); } } }); consumer.resume(); netSocket.resume(); }
@Test public void testDisconnectAbruptlyDuringStartup(TestContext ctx) { Async async = ctx.async(); ProxyServer proxy = ProxyServer.create(vertx, options.getPort(), options.getHost()); proxy.proxyHandler(conn -> { NetSocket clientSo = conn.clientSocket(); clientSo.handler(buff -> { clientSo.close(); }); clientSo.resume(); }); proxy.listen(8080, "localhost", ctx.asyncAssertSuccess(v1 -> { options.setPort(8080).setHost("localhost"); connector.accept(ctx.asyncAssertFailure(err -> async.complete())); })); }