@Override public void start(Future<Void> startFuture) throws Exception { termServer = TermServer.createTelnetTermServer(vertx, new TelnetTermOptions().setHost("localhost").setPort(3000).setInBinary(false)); Robot robot = new Robot(); termServer.termHandler(term -> { new ScreenCaster(vertx, robot, term).handle(); }); termServer.listen(ar -> { if (ar.succeeded()) { startFuture.complete(); } else { startFuture.fail(ar.cause()); } }); }
/** * Bind the term server, the {@link io.vertx.rxjava.ext.shell.term.TermServer#termHandler} must be set before. * @return this object */ public io.vertx.rxjava.ext.shell.term.TermServer listen() { delegate.listen(); return this; }
/** * Bind the term server, the {@link io.vertx.rxjava.ext.shell.term.TermServer#termHandler} must be set before. * @return this object */ public io.vertx.rxjava.ext.shell.term.TermServer listen() { delegate.listen(); return this; }
/** * Bind the term server, the {@link io.vertx.rxjava.ext.shell.term.TermServer#termHandler} must be set before. * @param listenHandler the listen handler * @return this object */ public io.vertx.rxjava.ext.shell.term.TermServer listen(Handler<AsyncResult<io.vertx.rxjava.ext.shell.term.TermServer>> listenHandler) { delegate.listen(new Handler<AsyncResult<io.vertx.ext.shell.term.TermServer>>() { public void handle(AsyncResult<io.vertx.ext.shell.term.TermServer> ar) { if (ar.succeeded()) { listenHandler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.ext.shell.term.TermServer.newInstance(ar.result()))); } else { listenHandler.handle(io.vertx.core.Future.failedFuture(ar.cause())); } } }); return this; }
/** * Bind the term server, the {@link io.vertx.rxjava.ext.shell.term.TermServer#termHandler} must be set before. * @param listenHandler the listen handler * @return this object */ public io.vertx.rxjava.ext.shell.term.TermServer listen(Handler<AsyncResult<io.vertx.rxjava.ext.shell.term.TermServer>> listenHandler) { delegate.listen(new Handler<AsyncResult<io.vertx.ext.shell.term.TermServer>>() { public void handle(AsyncResult<io.vertx.ext.shell.term.TermServer> ar) { if (ar.succeeded()) { listenHandler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.ext.shell.term.TermServer.newInstance(ar.result()))); } else { listenHandler.handle(io.vertx.core.Future.failedFuture(ar.cause())); } } }); return this; }
/** * Bind the term server, the {@link #termHandler(Handler)} must be set before. * * @return this object */ @Fluent default TermServer listen() { return listen(null); }
termServer.listen(handler); }); return this;
protected void startShell(SSHTermOptions options) throws ExecutionException, InterruptedException, TimeoutException { if (server != null) { throw new IllegalStateException(); } server = TermServer.createSSHTermServer(vertx, options); CompletableFuture<Void> fut = new CompletableFuture<>(); server.termHandler(termHandler); ((SSHServer)server).setExecHandler(execHandler); server.authProvider(authProvider); server.listen(ar -> { if (ar.succeeded()) { fut.complete(null); } else { fut.completeExceptionally(ar.cause()); } }); fut.get(10, TimeUnit.SECONDS); }
async.countDown(); }); server.listen(context.asyncAssertSuccess(server -> { HttpClient client = vertx.createHttpClient(); client.websocket(8080, "localhost", basePath + "/shell/websocket", new CaseInsensitiveHeaders().add("Authorization", "Basic " + Base64.getEncoder().encodeToString("paulo:anothersecret".getBytes())), ws -> {
@Test public void testKeymapFromFilesystem(TestContext context) throws Exception { URL url = TermServer.class.getResource(SSHTermOptions.DEFAULT_INPUTRC); File f = new File(url.toURI()); Async async = context.async(); server = createServer(context, new HttpTermOptions().setPort(8080).setIntputrc(f.getAbsolutePath())); server.termHandler(term -> { term.close(); async.complete(); }); server.listen(context.asyncAssertSuccess(server -> { HttpClient client = vertx.createHttpClient(); client.websocket(8080, "localhost", basePath + "/shell/websocket", new CaseInsensitiveHeaders().add("Authorization", "Basic " + Base64.getEncoder().encodeToString("paulo:anothersecret".getBytes())), ws -> { ws.handler(buf -> { }); }, context::fail); })); } }
@Test public void testExternalAuthProviderFails(TestContext context) throws Exception { AtomicInteger count = new AtomicInteger(); AuthProvider authProvider = (authInfo, resultHandler) -> { count.incrementAndGet(); resultHandler.handle(Future.failedFuture("not authenticated")); }; Async async = context.async(); server = createServer(context, new HttpTermOptions().setPort(8080)); server.authProvider(authProvider); server.termHandler(term -> { context.fail(); }); server.listen(context.asyncAssertSuccess(server -> { HttpClient client = vertx.createHttpClient(); client.websocket(8080, "localhost", basePath + "/shell/websocket", new CaseInsensitiveHeaders().add("Authorization", "Basic " + Base64.getEncoder().encodeToString("paulo:anothersecret".getBytes())), ws -> { context.fail(); }, err -> { assertEquals(1, count.get()); async.complete(); }); })); }
private void startTelnet(TestContext context, TelnetTermOptions options, Handler<Term> termHandler) { server = TermServer.createTelnetTermServer(vertx, options.setPort(4000)); server.termHandler(termHandler); Async async = context.async(); server.listen(context.asyncAssertSuccess(v -> async.complete())); async.awaitSuccess(5000); }
@Test public void testServerRead(TestContext context) { Async async = context.async(); server = createServer(context, new HttpTermOptions().setPort(8080)); server.termHandler(term -> { term.stdinHandler(buf -> { context.assertEquals("hello_from_client", buf); async.complete(); }); }); server.listen(context.asyncAssertSuccess(server -> { HttpClient client = vertx.createHttpClient(); client.websocket(8080, "localhost", basePath + "/shell/websocket", ws -> { ws.writeFinalTextFrame(new JsonObject().put("action", "read").put("data", "hello_from_client").encode()); }, context::fail); })); }
@Test public void testDifferentCharset(TestContext context) throws Exception { Async async = context.async(); server = createServer(context, new HttpTermOptions().setPort(8080).setCharset("ISO_8859_1")); server.termHandler(term -> { term.write("\u20AC"); term.close(); }); server.listen(context.asyncAssertSuccess(server -> { HttpClient client = vertx.createHttpClient(); client.websocket(8080, "localhost", basePath + "/shell/websocket", new CaseInsensitiveHeaders().add("Authorization", "Basic " + Base64.getEncoder().encodeToString("paulo:anothersecret".getBytes())), ws -> { ws.handler(buf -> { context.assertTrue(Arrays.equals(new byte[]{63}, buf.getBytes())); async.complete(); }); }, context::fail); })); }
@Test public void testResizeInvalid(TestContext context) { Async async = context.async(); server = createServer(context, new HttpTermOptions().setPort(8080));; server.termHandler(term -> { term.resizehandler(v -> { context.fail(); }); }); server.listen(context.asyncAssertSuccess(server -> { HttpClient client = vertx.createHttpClient(); client.websocket(8080, "localhost", basePath + "/shell/websocket", ws -> { ws.writeFinalTextFrame(new JsonObject().put("action", "resize").put("cols", -50).encode()); vertx.setTimer(1000, id -> { async.complete(); }); }, context::fail); })); }
@Test public void testSecure(TestContext context) { Async async = context.async(); server = createServer(context, new HttpTermOptions().setAuthOptions( new ShiroAuthOptions(). setType(ShiroAuthRealmType.PROPERTIES). setConfig(new JsonObject().put("properties_path", "classpath:test-auth.properties"))).setPort(8080)); server.termHandler(term -> { term.write("hello"); }); server.listen(context.asyncAssertSuccess(server -> { HttpClient client = vertx.createHttpClient(); client.websocket(8080, "localhost", basePath + "/shell/websocket", ws -> { context.fail(); }, err -> { // Retry now with auth client.websocket(8080, "localhost", basePath + "/shell/websocket", new CaseInsensitiveHeaders().add("Authorization", "Basic " + Base64.getEncoder().encodeToString("tim:sausages".getBytes())), ws -> { ws.handler(buf -> { context.assertEquals("hello", buf.toString()); async.complete(); }); }, context::fail); }); })); }
private void testSize(TestContext context, String uri, int expectedCols, int expectedRows) { Async async = context.async(); server = createServer(context, new HttpTermOptions().setPort(8080));; server.termHandler(term -> { context.assertEquals(expectedCols, term.width()); context.assertEquals(expectedRows, term.height()); async.complete(); }); server.listen(context.asyncAssertSuccess(server -> { HttpClient client = vertx.createHttpClient(); client.websocket(8080, "localhost", uri, ws -> { }, context::fail); })); }
@Test public void testServerWrite(TestContext context) { Async async = context.async(); server = createServer(context, new HttpTermOptions().setPort(8080)); server.termHandler(term -> { term.write("hello_from_server"); }); server.listen(context.asyncAssertSuccess(server -> { HttpClient client = vertx.createHttpClient(); client.websocket(8080, "localhost", basePath + "/shell/websocket", ws -> { ws.handler(buf -> { context.assertEquals("hello_from_server", buf.toString()); async.complete(); }); }, context::fail); })); }
private void testResize(TestContext context, JsonObject event, int expectedCols, int expectedRows) { Async async = context.async(); server = createServer(context, new HttpTermOptions().setPort(8080));; server.termHandler(term -> { term.resizehandler(v -> { context.assertEquals(expectedCols, term.width()); context.assertEquals(expectedRows, term.height()); async.complete(); }); }); server.listen(context.asyncAssertSuccess(server -> { HttpClient client = vertx.createHttpClient(); client.websocket(8080, "localhost", basePath + "/shell/websocket", ws -> { ws.writeFinalTextFrame(event.encode()); }, context::fail); })); }