--- /dev/null
+package org.argeo.cms.jshell;
+
+import java.io.ByteArrayOutputStream;
+import java.io.Console;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.StandardProtocolFamily;
+import java.net.UnixDomainSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.Channels;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.SocketChannel;
+import java.nio.channels.WritableByteChannel;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardWatchEventKinds;
+import java.nio.file.WatchEvent;
+import java.nio.file.WatchKey;
+import java.nio.file.WatchService;
+import java.util.UUID;
+
+public class JShellClient {
+ public final static String STDIO = "stdio";
+ public final static String STDERR = "stderr";
+ public final static String CMDIO = "cmdio";
+
+ private static String ttyConfig;
+
+ public static void main(String[] args) throws IOException, InterruptedException {
+ try {
+ Path targetStateDirectory = Paths.get(args[0]);
+ Path localBase = targetStateDirectory.resolve("jsh");
+ if (Files.isSymbolicLink(localBase)) {
+ localBase = localBase.toRealPath();
+ }
+
+ Console console = System.console();
+ if (console != null) {
+ toRawTerminal();
+ }
+
+ SocketPipeSource std = new SocketPipeSource();
+ std.setInputStream(System.in);
+ std.setOutputStream(System.out);
+
+ UUID uuid = UUID.randomUUID();
+ Path sessionDir = localBase.resolve(uuid.toString());
+ Files.createDirectory(sessionDir);
+ Path stdPath = sessionDir.resolve(JShellClient.STDIO);
+
+ // wait for sockets to be available
+ WatchService watchService = FileSystems.getDefault().newWatchService();
+ sessionDir.register(watchService, StandardWatchEventKinds.ENTRY_CREATE);
+ WatchKey key;
+ watch: while ((key = watchService.take()) != null) {
+ for (WatchEvent<?> event : key.pollEvents()) {
+ Path path = sessionDir.resolve((Path) event.context());
+ if (Files.isSameFile(stdPath, path)) {
+ break watch;
+ }
+ }
+ }
+ watchService.close();
+
+ UnixDomainSocketAddress stdSocketAddress = UnixDomainSocketAddress.of(stdPath);
+
+ SocketChannel channel = SocketChannel.open(StandardProtocolFamily.UNIX);
+ channel.connect(stdSocketAddress);
+
+ std.forward(channel);
+ } catch (IOException | InterruptedException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ } finally {
+ try {
+ stty(ttyConfig.trim());
+ } catch (Exception e) {
+ System.err.println("Exception restoring tty config");
+ }
+ }
+
+ }
+
+ private static void toRawTerminal() throws IOException, InterruptedException {
+
+ ttyConfig = stty("-g");
+
+ // set the console to be character-buffered instead of line-buffered
+ stty("-icanon min 1");
+
+ // disable character echoing
+ stty("-echo");
+
+ Runtime.getRuntime().addShutdownHook(new Thread(() -> toOriginalTerminal(), "Reset terminal"));
+ }
+
+ private static void toOriginalTerminal() {
+ if (ttyConfig != null)
+ try {
+ stty(ttyConfig.trim());
+ } catch (Exception e) {
+ System.err.println("Exception restoring tty config");
+ }
+ }
+
+ /**
+ * Execute the stty command with the specified arguments against the current
+ * active terminal.
+ */
+ private static String stty(final String args) throws IOException, InterruptedException {
+ String cmd = "stty " + args + " < /dev/tty";
+
+ return exec(new String[] { "sh", "-c", cmd });
+ }
+
+ /**
+ * Execute the specified command and return the output (both stdout and stderr).
+ */
+ private static String exec(final String[] cmd) throws IOException, InterruptedException {
+ ByteArrayOutputStream bout = new ByteArrayOutputStream();
+
+ Process p = Runtime.getRuntime().exec(cmd);
+ int c;
+ InputStream in = p.getInputStream();
+
+ while ((c = in.read()) != -1) {
+ bout.write(c);
+ }
+
+ in = p.getErrorStream();
+
+ while ((c = in.read()) != -1) {
+ bout.write(c);
+ }
+
+ p.waitFor();
+
+ String result = new String(bout.toByteArray());
+ return result;
+ }
+
+// void pipe() throws IOException {
+// // Set up Server Socket and bind to the port 8000
+// ServerSocketChannel server = ServerSocketChannel.open();
+// SocketAddress endpoint = new InetSocketAddress(8000);
+// server.socket().bind(endpoint);
+//
+// server.configureBlocking(false);
+//
+// // Set up selector so we can run with a single thread but multiplex between 2
+// // channels
+// Selector selector = Selector.open();
+// server.register(selector, SelectionKey.OP_ACCEPT);
+//
+// ByteBuffer buffer = ByteBuffer.allocate(1024);
+//
+// while (true) {
+// // block until data comes in
+// selector.select();
+//
+// Set<SelectionKey> keys = selector.selectedKeys();
+//
+// for (SelectionKey key : keys) {
+// if (!key.isValid()) {
+// // not valid or writable so skip
+// continue;
+// }
+//
+// if (key.isAcceptable()) {
+// // Accept socket channel for client connection
+// ServerSocketChannel channel = (ServerSocketChannel) key.channel();
+// SocketChannel accept = channel.accept();
+// setupConnection(selector, accept);
+// } else if (key.isReadable()) {
+// try {
+// // Read into the buffer from the socket and then write the buffer into the
+// // attached socket.
+// SocketChannel recv = (SocketChannel) key.channel();
+// SocketChannel send = (SocketChannel) key.attachment();
+// recv.read(buffer);
+// buffer.flip();
+// send.write(buffer);
+// buffer.rewind();
+// } catch (IOException e) {
+// e.printStackTrace();
+//
+// // Close sockets
+// if (key.channel() != null)
+// key.channel().close();
+// if (key.attachment() != null)
+// ((SocketChannel) key.attachment()).close();
+// }
+// } else if (key.isWritable()) {
+//
+// }
+// }
+//
+// // Clear keys for next select
+// keys.clear();
+// }
+//
+// }
+
+// public static void mainX(String[] args) throws IOException, InterruptedException {
+// toRawTerminal();
+// try {
+// boolean client = true;
+// if (client) {
+// ReadableByteChannel inChannel;
+// WritableByteChannel outChannel;
+// inChannel = Channels.newChannel(System.in);
+// outChannel = Channels.newChannel(System.out);
+//
+// SocketChannel channel = SocketChannel.open(StandardProtocolFamily.UNIX);
+// channel.connect(ioSocketAddress());
+//
+// new Thread(() -> {
+//
+// try {
+// ByteBuffer buffer = ByteBuffer.allocate(1024);
+// while (true) {
+// if (channel.read(buffer) < 0)
+// break;
+// buffer.flip();
+// outChannel.write(buffer);
+// buffer.rewind();
+// }
+// System.exit(0);
+// } catch (IOException e) {
+// e.printStackTrace();
+// }
+// }, "Read out").start();
+//
+// ByteBuffer buffer = ByteBuffer.allocate(1);
+// while (channel.isConnected()) {
+// if (inChannel.read(buffer) < 0)
+// break;
+// buffer.flip();
+// channel.write(buffer);
+// buffer.rewind();
+// }
+//
+// } else {
+// ServerSocketChannel serverChannel = ServerSocketChannel.open(StandardProtocolFamily.UNIX);
+// serverChannel.bind(ioSocketAddress());
+//
+// SocketChannel channel = serverChannel.accept();
+//
+// while (true) {
+// readSocketMessage(channel).ifPresent(message -> System.out.printf("[Client message] %s", message));
+// Thread.sleep(100);
+// }
+// }
+// } finally {
+// toOriginalTerminal();
+// }
+// }
+//
+// private static Optional<String> readSocketMessage(SocketChannel channel) throws IOException {
+// ByteBuffer buffer = ByteBuffer.allocate(1024);
+// int bytesRead = channel.read(buffer);
+// if (bytesRead < 0)
+// return Optional.empty();
+//
+// byte[] bytes = new byte[bytesRead];
+// buffer.flip();
+// buffer.get(bytes);
+// String message = new String(bytes);
+// return Optional.of(message);
+// }
+//
+// public static void setupConnection(Selector selector, SocketChannel client) throws IOException {
+// // Connect to the remote server
+// SocketAddress address = new InetSocketAddress("192.168.1.74", 8000);
+// SocketChannel remote = SocketChannel.open(address);
+//
+// // Make sockets non-blocking (should be better performance)
+// client.configureBlocking(false);
+// remote.configureBlocking(false);
+//
+// client.register(selector, SelectionKey.OP_READ, remote);
+// remote.register(selector, SelectionKey.OP_READ, client);
+// }
+//
+// static UnixDomainSocketAddress ioSocketAddress() throws IOException {
+// String system = "default";
+// String bundleSn = "org.argeo.slc.jshell";
+//
+// String xdgRunDir = System.getenv("XDG_RUNTIME_DIR");
+// Path baseRunDir = Paths.get(xdgRunDir);
+// Path jshellSocketBase = baseRunDir.resolve("jshell").resolve(system).resolve(bundleSn);
+//
+// Files.createDirectories(jshellSocketBase);
+//
+// Path ioSocketPath = jshellSocketBase.resolve("io");
+//
+// UnixDomainSocketAddress ioSocketAddress = UnixDomainSocketAddress.of(ioSocketPath);
+// System.out.println(ioSocketAddress);
+// return ioSocketAddress;
+// }
+
+}
+
+class SocketPipeSource {
+ private ReadableByteChannel inChannel;
+ private WritableByteChannel outChannel;
+
+ private Thread readOutThread;
+
+ public void forward(SocketChannel channel) throws IOException {
+ readOutThread = new Thread(() -> {
+
+ try {
+ ByteBuffer buffer = ByteBuffer.allocate(1024);
+ while (true) {
+ if (channel.read(buffer) < 0)
+ break;
+ buffer.flip();
+ outChannel.write(buffer);
+ buffer.rewind();
+ }
+ System.exit(0);
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }, "Read out");
+ readOutThread.start();
+
+ // TODO make it smarter than a 1 byte buffer
+ // we should recognize control characters
+ // e.g ^C
+// int c = System.in.read();
+// if (c == 0x1B) {
+// break;
+// }
+
+ ByteBuffer buffer = ByteBuffer.allocate(1);
+ while (channel.isConnected()) {
+ if (inChannel.read(buffer) < 0)
+ break;
+ buffer.flip();
+ channel.write(buffer);
+ buffer.rewind();
+ }
+
+ // end
+ // TODO make it more robust
+ try {
+ // TODO add timeout
+ readOutThread.join();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+
+ public void setInputStream(InputStream in) {
+ inChannel = Channels.newChannel(in);
+ }
+
+ public void setOutputStream(OutputStream out) {
+ outChannel = Channels.newChannel(out);
+ }
+}
projects / lgpl / argeo-commons.git / blobdiff