@Override public void start() throws Exception { Command starwars = CommandBuilder.command("echokeyboard"). processHandler(process -> { // Echo process.stdinHandler(keys -> { process.write(keys.replace('\r', '\n')); }); // Terminate when user hits Ctrl-C process.interruptHandler(v -> { process.end(); }); }).build(vertx); ShellService service = ShellService.create(vertx, new ShellServiceOptions().setTelnetOptions( new TelnetTermOptions().setHost("localhost").setPort(3000) )); CommandRegistry.getShared(vertx).registerCommand(starwars); service.start(ar -> { if (!ar.succeeded()) { ar.cause().printStackTrace(); } }); } }
public io.vertx.rxjava.ext.shell.command.CommandProcess stdinHandler(Handler<String> handler) { delegate.stdinHandler(handler); return this; }
public io.vertx.rxjava.ext.shell.command.CommandProcess stdinHandler(Handler<String> handler) { delegate.stdinHandler(handler); return this; }
@Test public void testHandleReadlineBuffered(TestContext context) { TestTtyConnection conn = new TestTtyConnection(vertx); ShellImpl shell = createShell(conn); shell.init().readline(); Async async = context.async(); commands.add(CommandBuilder.command("_not_consumed").processHandler(process -> { async.complete(); })); commands.add(CommandBuilder.command("read").processHandler(process -> { StringBuilder buffer = new StringBuilder(); process.stdinHandler(line -> { buffer.append(line); if (buffer.toString().equals("the_line")) { process.end(); } }); })); conn.read("read\rthe_line_not_consumed\r"); }
@Override public void testExec(TestContext context) throws Exception { AtomicReference<Vertx> execCommand = new AtomicReference<>(); CommandRegistry registry = CommandRegistry.getShared(vertx); registry.registerCommand(CommandBuilder.command("the-command").processHandler(process -> { context.assertNotNull(Vertx.currentContext()); context.assertNotNull(process.session()); execCommand.set(process.vertx()); context.assertEquals(-1, process.width()); context.assertEquals(-1, process.height()); context.assertEquals(Arrays.asList("arg1", "arg2"), process.args()); context.assertTrue(process.isForeground()); StringBuilder input = new StringBuilder(); process.stdinHandler(data -> { input.append(data); if (input.toString().equals("the_input")) { process.end(2); } }); process.write("the_output"); }).build(vertx)); super.testExec(context); assertEquals(execCommand.get(), vertx); } }
latch3.countDown(); }); process.stdinHandler(txt -> { context.assertEquals(0L, latch3.getCount()); context.assertEquals("hello", txt);
@Test public void testStdin(TestContext context) { CountDownLatch latch = new CountDownLatch(1); commands.add(CommandBuilder.command("foo").processHandler(process -> { process.stdinHandler(data -> { context.assertEquals("hello_world", data); process.end(0); }); latch.countDown(); })); Shell shell = server.createShell(); Job job = shell.createJob(CliToken.tokenize("foo")); Async async = context.async(); Pty pty = Pty.create(); job.setTty(pty.slave()); job.statusUpdateHandler(CommandProcessTest.terminateHandler(code -> { context.assertEquals(0, job.process().exitCode()); async.complete(); })).run(); try { latch.await(10, TimeUnit.SECONDS); } catch (InterruptedException e) { context.fail(e); } pty.write("hello_world"); }
commands.add(CommandBuilder.command("foo").processHandler(process -> { context.assertEquals(null, conn.checkWritten(prompt1+"foo\n")); process.stdinHandler(cp -> { context.fail(); }); commands.add(CommandBuilder.command("bar2").processHandler(process -> { context.assertEquals(null, conn.checkWritten(prompt2+"bar2\n")); process.stdinHandler(cp -> { context.fail(); });
process.stdinHandler(line -> { process.write("-> " + line + "\n"); });
@Test public void testSetStdinOnResumeToForeground(TestContext context) throws Exception { Async fooRunning = context.async(); Async fooSusp = context.async(); Async fooResumed = context.async(); Async readLatch = context.async(); commands.add( CommandBuilder.command("foo").processHandler(process -> { process.suspendHandler(v -> fooSusp.complete()); process.resumeHandler(v -> fooResumed.complete()); process.stdinHandler(line -> { context.assertEquals("foo_msg", line); readLatch.complete(); }); fooRunning.complete(); })); TestTtyConnection conn = new TestTtyConnection(vertx); ShellImpl shell = createShell(conn); shell.init().readline(); conn.read("foo\r"); fooRunning.awaitSuccess(2000); conn.sendEvent(TtyEvent.SUSP); fooSusp.awaitSuccess(2000); conn.read("fg\r"); fooResumed.awaitSuccess(2000); conn.read("foo_msg"); }
command("foo"). processHandler(process -> { process.stdinHandler(cp -> { context.fail(); });
@Test public void testPrompt(TestContext context) { commands = new TestCommands(vertx); ShellServer server = ShellServer.create(vertx, new ShellServerOptions() .setWelcomeMessage("") .setSessionTimeout(100) .setReaperInterval(100)); server.shellHandler(shell -> shell.setPrompt(s -> "FOOPROMPT")); TestTermServer termServer = new TestTermServer(vertx); server.registerTermServer(termServer); server. registerCommandResolver(CommandResolver.baseCommands(vertx)). registerCommandResolver(commands). listen(context.asyncAssertSuccess()); TestTtyConnection conn = termServer.openConnection(); Async async = context.async(); commands.add(CommandBuilder.command("foo").processHandler(process -> { context.assertEquals(null, conn.checkWritten("FOOPROMPTfoo\n")); process.stdinHandler(cp -> { context.fail(); }); process.endHandler(v -> { async.complete(); } ); process.end(); })); conn.read("foo\r"); async.awaitSuccess(5000); }
process.resumeHandler(v -> fooResumed.complete()); process.foregroundHandler(v -> fooToForeground.complete()); process.stdinHandler(line -> { context.assertEquals("foo_msg", line); readLatch.complete();
process.write("resumed"); }); process.stdinHandler(txt -> { context.fail(); });
Async latch3 = context.async(); commands.add(CommandBuilder.command("read").processHandler(process -> { process.stdinHandler(line -> { context.fail("Should not process line " + line); });
Context currentCtx = Vertx.currentContext(); testContext.assertTrue(commandCtx == currentCtx); process.stdinHandler(text -> { testContext.assertTrue(commandCtx == Vertx.currentContext()); testContext.assertEquals("ping", text);
latch3.countDown(); }); process.stdinHandler(line -> { async.complete(); });