public static void main(String[] argv) throws Exception { Pipe[] pipes = new Pipe[PIPES_COUNT]; Pipe pipe = Pipe.open(); Pipe.SinkChannel sink = pipe.sink(); Pipe.SourceChannel source = pipe.source(); Selector sel = Selector.open(); source.configureBlocking(false); source.register(sel, SelectionKey.OP_READ); for (int i = 0; i < PIPES_COUNT; i++) { pipes[i] = Pipe.open(); Pipe.SourceChannel sc = pipes[i].source(); sc.configureBlocking(false); sc.register(sel, SelectionKey.OP_READ); Pipe.SinkChannel sc2 = pipes[i].sink(); sc2.configureBlocking(false); sc2.register(sel, SelectionKey.OP_WRITE); } for (int i = 0; i < LOOPS; i++) { sink.write(ByteBuffer.allocate(BUF_SIZE)); int x = sel.selectNow(); sel.selectedKeys().clear(); source.read(ByteBuffer.allocate(BUF_SIZE)); } for (int i = 0; i < PIPES_COUNT; i++) { pipes[i].sink().close(); pipes[i].source().close(); } pipe.sink().close(); pipe.source().close(); sel.close(); }
private static void scScatter() throws Exception { Pipe p = Pipe.open(); Pipe.SinkChannel sink = p.sink(); Pipe.SourceChannel source = p.source(); sink.configureBlocking(false); ByteBuffer outgoingdata = ByteBuffer.allocateDirect(30); byte[] someBytes = new byte[30]; generator.nextBytes(someBytes); outgoingdata.put(someBytes); outgoingdata.flip(); int totalWritten = 0; while (totalWritten < 30) { int written = sink.write(outgoingdata); if (written < 0) throw new Exception("Write failed"); totalWritten += written; } ByteBuffer[] bufs = new ByteBuffer[3]; for (int i = 0; i < 3; i++) bufs[i] = ByteBuffer.allocateDirect(10); long numBytesRead = source.read(bufs); if (numBytesRead < 30) throw new Exception("Pipe test failed"); sink.close(); source.close(); }
/** * A convenience method for the following code: * * <pre> * {@link Pipe} inputToOutput = {@link Pipe#open()}; * {@link Pipe.SinkChannel} sink = {@link Pipe#sink() inputToOutput.sink()}; * {@link SelectableChannel#configureBlocking(boolean) sink.configureBlocking(false)}; * {@link #addRoute(SelectableChannel, SelectableChannel) addRoute(input, sink)}; * * {@link Pipe.SourceChannel} source = {@link Pipe#source() inputToOutput.source()}; * return {@link #wrapChannelInObjectInputStream(ReadableByteChannel) wrapChannelInObjectInputStream(source)}; * </pre> * * @throws IOException pass-through for any {@link IOException} that occurs in the above code */ public <T extends SelectableChannel & ReadableByteChannel> ObjectInputStream addRouteToObjectInputStream(T input) throws IOException { Pipe inputToOutput = Pipe.open(); Pipe.SinkChannel sink = inputToOutput.sink(); sink.configureBlocking(false); addRoute(input, sink); Pipe.SourceChannel source = inputToOutput.source(); return wrapChannelInObjectInputStream(source); }
/** * A convenience method for the following code: * * <pre> * {@link Pipe} inputToOutput = {@link Pipe#open()}; * {@link Pipe.SourceChannel} source = {@link Pipe#source() inputToOutput.source()}; * {@link SelectableChannel#configureBlocking(boolean) source.configureBlocking(false)}; * {@link #addRoute(SelectableChannel, SelectableChannel) addRoute(source, output)}; * * {@link Pipe.SinkChannel} sink = {@link Pipe#sink() inputToOutput.sink()}; * return {@link #wrapChannelInObjectOutputStream(WritableByteChannel) wrapChannelInObjectOutputStream(sink)}; * </pre> * * Users must call {@link ObjectOutputStream#flush()} before attempting to construct a matching * {@link ObjectInputStream} to ensure a serialization header is available. * * @throws IOException pass-through for any {@link IOException} that occurs in the above code */ public <T extends SelectableChannel & WritableByteChannel> ObjectOutputStream addRouteFromObjectOutputStream(T output) throws IOException { Pipe inputToOutput = Pipe.open(); Pipe.SourceChannel source = inputToOutput.source(); source.configureBlocking(false); addRoute(source, output); Pipe.SinkChannel sink = inputToOutput.sink(); return wrapChannelInObjectOutputStream(sink); }
public PipeManager() { setPipes(new Vector()); for (Iterator itr = Config.getConfig().getPipes().iterator(); itr.hasNext(); ) { String tmp = itr.next().toString(); if (tmp != null) { Pipe p = getPipe(tmp); if (p != null) { p.open(); getPipes().add(p); } } } }
public Overlord() { try { selector = Selector.open(); queue = new ConcurrentLinkedQueue<Communicator>(); // open the pipe and register it with our selector pipe = Pipe.open(); pipe.sink().configureBlocking(false); pipe.source().configureBlocking(false); pipe.source().register(selector, SelectionKey.OP_READ); } catch (IOException e) { throw new RuntimeException("select() failed"); } }
public static void main(String[] args) throws IOException { ChannelRouter channelRouter = new ChannelRouter( new ExceptionListener<IOException>() { @Override public void exceptionThrown(IOException exception) { exception.printStackTrace(); } }); int port = Integer.parseInt(args[1]); SocketChannel socketChannel; if (args[0].equals("--server")) { System.out.println("Server mode started; listening on port " + port); ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); serverSocketChannel.socket().bind(new InetSocketAddress(port)); socketChannel = serverSocketChannel.accept(); System.out.println("Client connected"); serverSocketChannel.close(); } else { String host = args[0]; System.out.println("Client mode started; connecting to " + host + " on port " + port); socketChannel = SocketChannel.open(new InetSocketAddress(host, port)); System.out.println("Connected to server"); } socketChannel.configureBlocking(false); Pipe localToRemote = Pipe.open(); localToRemote.source().configureBlocking(false); channelRouter.addRoute(localToRemote.source(), socketChannel); final Pipe remoteToLocal = Pipe.open(); remoteToLocal.sink().configureBlocking(false); channelRouter.addRoute(socketChannel, remoteToLocal.sink()); Thread channelRouterThread = new Thread(channelRouter, "ChannelRouter"); channelRouterThread.start(); Thread remoteReaderThread = new Thread("RemoteReader") { @Override public void run() { try { // BufferedReader.readLine() blocks until an end-of-line is // written, so make sure they get written by the main thread InputStream temporaryInputStream = Channels.newInputStream(remoteToLocal.source()); BufferedReader in = new BufferedReader(new InputStreamReader(temporaryInputStream)); String line = in.readLine(); while (null != line) { System.out.println(line); line = in.readLine(); } } catch (ClosedByInterruptException e) { // The main thread wants us to close, so do nothing } catch (IOException e) { e.printStackTrace(); } } }; remoteReaderThread.start(); BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); Writer temporaryWriter = new OutputStreamWriter(Channels.newOutputStream(localToRemote.sink())); temporaryWriter = new BufferedWriter(temporaryWriter); PrintWriter out = new PrintWriter(temporaryWriter, true); System.out.println( "Press end-of-file to terminate (Ctrl+Z on Windows, Ctrl+D on other platforms)"); String line = in.readLine(); while (null != line) { // The end-of-line is required for BufferedReader.readLine() to // return and this will automatically flush due to the auto-flush // parameter on construction out.println(line); line = in.readLine(); } remoteReaderThread.interrupt(); channelRouterThread.interrupt(); socketChannel.close(); }
public boolean addPipe(Pipe p) { p.open(); return getPipes().add(p); }
public boolean setupLurkPipe(Channel in, Channel out) { Pipe p = new LurkPipe(in, out); p.open(); getPipes().add(p); return true; }