Example usage for java.nio.channels SelectionKey isAcceptable

List of usage examples for java.nio.channels SelectionKey isAcceptable

Introduction

In this page you can find the example usage for java.nio.channels SelectionKey isAcceptable.

Prototype

public final boolean isAcceptable() 

Source Link

Document

Tests whether this key's channel is ready to accept a new socket connection.

Usage

From source file:Main.java

public static void main(String[] argv) throws Exception {
    Selector selector = Selector.open();

    ServerSocketChannel ssChannel1 = ServerSocketChannel.open();
    ssChannel1.configureBlocking(false);
    ssChannel1.socket().bind(new InetSocketAddress(80));

    ServerSocketChannel ssChannel2 = ServerSocketChannel.open();
    ssChannel2.configureBlocking(false);
    ssChannel2.socket().bind(new InetSocketAddress(81));

    ssChannel1.register(selector, SelectionKey.OP_ACCEPT);
    ssChannel2.register(selector, SelectionKey.OP_ACCEPT);

    while (true) {
        selector.select();/*from  ww w  .j  av a 2 s. co m*/
        Iterator it = selector.selectedKeys().iterator();
        while (it.hasNext()) {
            SelectionKey selKey = (SelectionKey) it.next();
            it.remove();

            if (selKey.isAcceptable()) {
                ServerSocketChannel ssChannel = (ServerSocketChannel) selKey.channel();
                SocketChannel sc = ssChannel.accept();
                ByteBuffer bb = ByteBuffer.allocate(100);
                sc.read(bb);

            }
        }
    }
}

From source file:Main.java

public static void main(String[] argv) throws Exception {
    Selector selector = Selector.open();

    ServerSocketChannel ssChannel1 = ServerSocketChannel.open();
    ssChannel1.configureBlocking(false);
    ssChannel1.socket().bind(new InetSocketAddress(80));

    ServerSocketChannel ssChannel2 = ServerSocketChannel.open();
    ssChannel2.configureBlocking(false);
    ssChannel2.socket().bind(new InetSocketAddress(81));

    ssChannel1.register(selector, SelectionKey.OP_ACCEPT);
    ssChannel2.register(selector, SelectionKey.OP_ACCEPT);

    while (true) {
        selector.select();/*from w  ww.ja  v a2 s . co  m*/
        Iterator it = selector.selectedKeys().iterator();
        while (it.hasNext()) {
            SelectionKey selKey = (SelectionKey) it.next();
            it.remove();

            if (selKey.isAcceptable()) {
                ServerSocketChannel ssChannel = (ServerSocketChannel) selKey.channel();
                SocketChannel sc = ssChannel.accept();
                ByteBuffer buf = ByteBuffer.allocate(100);
                int numBytesRead = sc.read(buf);

                if (numBytesRead == -1) {
                    sc.close();
                } else {
                    // Read the bytes from the buffer
                }
                int numBytesWritten = sc.write(buf);
            }
        }
    }
}

From source file:MainClass.java

public static void main(String[] args) throws IOException {
    for (int i = 0; i < data.length; i++)
        data[i] = (byte) i;

    ServerSocketChannel server = ServerSocketChannel.open();
    server.configureBlocking(false);//from w w w.  j ava2s.  c o  m

    server.socket().bind(new InetSocketAddress(9000));
    Selector selector = Selector.open();
    server.register(selector, SelectionKey.OP_ACCEPT);

    while (true) {
        selector.select();
        Set readyKeys = selector.selectedKeys();
        Iterator iterator = readyKeys.iterator();
        while (iterator.hasNext()) {
            SelectionKey key = (SelectionKey) iterator.next();
            iterator.remove();
            if (key.isAcceptable()) {
                SocketChannel client = server.accept();
                System.out.println("Accepted connection from " + client);
                client.configureBlocking(false);
                ByteBuffer source = ByteBuffer.wrap(data);
                SelectionKey key2 = client.register(selector, SelectionKey.OP_WRITE);
                key2.attach(source);
            } else if (key.isWritable()) {
                SocketChannel client = (SocketChannel) key.channel();
                ByteBuffer output = (ByteBuffer) key.attachment();
                if (!output.hasRemaining()) {
                    output.rewind();
                }
                client.write(output);
            }
            key.channel().close();
        }
    }
}

From source file:NewFingerServer.java

public static void main(String[] arguments) throws Exception {
    ServerSocketChannel sockChannel = ServerSocketChannel.open();
    sockChannel.configureBlocking(false);

    InetSocketAddress server = new InetSocketAddress("localhost", 79);
    ServerSocket socket = sockChannel.socket();
    socket.bind(server);/*from   w w  w.j  ava  2s.c  o  m*/

    Selector selector = Selector.open();
    sockChannel.register(selector, SelectionKey.OP_ACCEPT);

    while (true) {
        selector.select();
        Set keys = selector.selectedKeys();
        Iterator it = keys.iterator();
        while (it.hasNext()) {
            SelectionKey selKey = (SelectionKey) it.next();
            it.remove();
            if (selKey.isAcceptable()) {
                ServerSocketChannel selChannel = (ServerSocketChannel) selKey.channel();
                ServerSocket selSocket = selChannel.socket();
                Socket connection = selSocket.accept();

                InputStreamReader isr = new InputStreamReader(connection.getInputStream());
                BufferedReader is = new BufferedReader(isr);
                PrintWriter pw = new PrintWriter(new BufferedOutputStream(connection.getOutputStream()), false);
                pw.println("NIO Finger Server");
                pw.flush();
                String outLine = null;
                String inLine = is.readLine();
                if (inLine.length() > 0) {
                    outLine = inLine;
                }
                readPlan(outLine, pw);
                pw.flush();
                pw.close();
                is.close();

                connection.close();
            }
        }
    }
}

From source file:MainClass.java

public static void main(String[] args) throws IOException {
    Charset charset = Charset.forName("ISO-8859-1");
    CharsetEncoder encoder = charset.newEncoder();
    CharsetDecoder decoder = charset.newDecoder();

    ByteBuffer buffer = ByteBuffer.allocate(512);

    Selector selector = Selector.open();

    ServerSocketChannel server = ServerSocketChannel.open();
    server.socket().bind(new java.net.InetSocketAddress(8000));
    server.configureBlocking(false);//from   w w w .  ja v a2s . co  m
    SelectionKey serverkey = server.register(selector, SelectionKey.OP_ACCEPT);

    for (;;) {
        selector.select();
        Set keys = selector.selectedKeys();

        for (Iterator i = keys.iterator(); i.hasNext();) {
            SelectionKey key = (SelectionKey) i.next();
            i.remove();

            if (key == serverkey) {
                if (key.isAcceptable()) {
                    SocketChannel client = server.accept();
                    client.configureBlocking(false);
                    SelectionKey clientkey = client.register(selector, SelectionKey.OP_READ);
                    clientkey.attach(new Integer(0));
                }
            } else {
                SocketChannel client = (SocketChannel) key.channel();
                if (!key.isReadable())
                    continue;
                int bytesread = client.read(buffer);
                if (bytesread == -1) {
                    key.cancel();
                    client.close();
                    continue;
                }
                buffer.flip();
                String request = decoder.decode(buffer).toString();
                buffer.clear();
                if (request.trim().equals("quit")) {
                    client.write(encoder.encode(CharBuffer.wrap("Bye.")));
                    key.cancel();
                    client.close();
                } else {
                    int num = ((Integer) key.attachment()).intValue();
                    String response = num + ": " + request.toUpperCase();
                    client.write(encoder.encode(CharBuffer.wrap(response)));
                    key.attach(new Integer(num + 1));
                }
            }
        }
    }
}

From source file:DaytimeServer.java

public static void main(String args[]) {
    try { // Handle startup exceptions at the end of this block
        // Get an encoder for converting strings to bytes
        CharsetEncoder encoder = Charset.forName("US-ASCII").newEncoder();

        // Allow an alternative port for testing with non-root accounts
        int port = 13; // RFC867 specifies this port.
        if (args.length > 0)
            port = Integer.parseInt(args[0]);

        // The port we'll listen on
        SocketAddress localport = new InetSocketAddress(port);

        // Create and bind a tcp channel to listen for connections on.
        ServerSocketChannel tcpserver = ServerSocketChannel.open();
        tcpserver.socket().bind(localport);

        // Also create and bind a DatagramChannel to listen on.
        DatagramChannel udpserver = DatagramChannel.open();
        udpserver.socket().bind(localport);

        // Specify non-blocking mode for both channels, since our
        // Selector object will be doing the blocking for us.
        tcpserver.configureBlocking(false);
        udpserver.configureBlocking(false);

        // The Selector object is what allows us to block while waiting
        // for activity on either of the two channels.
        Selector selector = Selector.open();

        // Register the channels with the selector, and specify what
        // conditions (a connection ready to accept, a datagram ready
        // to read) we'd like the Selector to wake up for.
        // These methods return SelectionKey objects, which we don't
        // need to retain in this example.
        tcpserver.register(selector, SelectionKey.OP_ACCEPT);
        udpserver.register(selector, SelectionKey.OP_READ);

        // This is an empty byte buffer to receive emtpy datagrams with.
        // If a datagram overflows the receive buffer size, the extra bytes
        // are automatically discarded, so we don't have to worry about
        // buffer overflow attacks here.
        ByteBuffer receiveBuffer = ByteBuffer.allocate(0);

        // Now loop forever, processing client connections
        for (;;) {
            try { // Handle per-connection problems below
                // Wait for a client to connect
                selector.select();//from  w ww .  j  a va  2s.  com

                // If we get here, a client has probably connected, so
                // put our response into a ByteBuffer.
                String date = new java.util.Date().toString() + "\r\n";
                ByteBuffer response = encoder.encode(CharBuffer.wrap(date));

                // Get the SelectionKey objects for the channels that have
                // activity on them. These are the keys returned by the
                // register() methods above. They are returned in a
                // java.util.Set.
                Set keys = selector.selectedKeys();

                // Iterate through the Set of keys.
                for (Iterator i = keys.iterator(); i.hasNext();) {
                    // Get a key from the set, and remove it from the set
                    SelectionKey key = (SelectionKey) i.next();
                    i.remove();

                    // Get the channel associated with the key
                    Channel c = (Channel) key.channel();

                    // Now test the key and the channel to find out
                    // whether something happend on the TCP or UDP channel
                    if (key.isAcceptable() && c == tcpserver) {
                        // A client has attempted to connect via TCP.
                        // Accept the connection now.
                        SocketChannel client = tcpserver.accept();
                        // If we accepted the connection successfully,
                        // the send our respone back to the client.
                        if (client != null) {
                            client.write(response); // send respone
                            client.close(); // close connection
                        }
                    } else if (key.isReadable() && c == udpserver) {
                        // A UDP datagram is waiting. Receive it now,
                        // noting the address it was sent from.
                        SocketAddress clientAddress = udpserver.receive(receiveBuffer);
                        // If we got the datagram successfully, send
                        // the date and time in a response packet.
                        if (clientAddress != null)
                            udpserver.send(response, clientAddress);
                    }
                }
            } catch (java.io.IOException e) {
                // This is a (hopefully transient) problem with a single
                // connection: we log the error, but continue running.
                // We use our classname for the logger so that a sysadmin
                // can configure logging for this server independently
                // of other programs.
                Logger l = Logger.getLogger(DaytimeServer.class.getName());
                l.log(Level.WARNING, "IOException in DaytimeServer", e);
            } catch (Throwable t) {
                // If anything else goes wrong (out of memory, for example)
                // then log the problem and exit.
                Logger l = Logger.getLogger(DaytimeServer.class.getName());
                l.log(Level.SEVERE, "FATAL error in DaytimeServer", t);
                System.exit(1);
            }
        }
    } catch (Exception e) {
        // This is a startup error: there is no need to log it;
        // just print a message and exit
        System.err.println(e);
        System.exit(1);
    }
}

From source file:PrintServiceWebInterface.java

public static void main(String[] args) throws IOException {
    // Get the character encoders and decoders we'll need
    Charset charset = Charset.forName("ISO-8859-1");
    CharsetEncoder encoder = charset.newEncoder();

    // The HTTP headers we send back to the client are fixed
    String headers = "HTTP/1.1 200 OK\r\n" + "Content-type: text/html\r\n" + "Connection: close\r\n" + "\r\n";

    // We'll use two buffers in our response. One holds the fixed
    // headers, and the other holds the variable body of the response.
    ByteBuffer[] buffers = new ByteBuffer[2];
    buffers[0] = encoder.encode(CharBuffer.wrap(headers));
    ByteBuffer body = ByteBuffer.allocateDirect(16 * 1024);
    buffers[1] = body;//w  w w  .  j  av  a2s.co  m

    // Find all available PrintService objects to describe
    PrintService[] services = PrintServiceLookup.lookupPrintServices(null, null);

    // All of the channels we use in this code will be in non-blocking
    // mode. So we create a Selector object that will block while
    // monitoring all of the channels and will only stop blocking when
    // one or more of the channels is ready for I/O of some sort.
    Selector selector = Selector.open();

    // Create a new ServerSocketChannel, and bind it to port 8000.
    // Note that we have to do this using the underlying ServerSocket.
    ServerSocketChannel server = ServerSocketChannel.open();
    server.socket().bind(new java.net.InetSocketAddress(8000));

    // Put the ServerSocketChannel into non-blocking mode
    server.configureBlocking(false);

    // Now register the channel with the Selector. The SelectionKey
    // represents the registration of this channel with this Selector.
    SelectionKey serverkey = server.register(selector, SelectionKey.OP_ACCEPT);

    for (;;) { // The main server loop. The server runs forever.
        // This call blocks until there is activity on one of the
        // registered channels. This is the key method in non-blocking I/O.
        selector.select();

        // Get a java.util.Set containing the SelectionKey objects for
        // all channels that are ready for I/O.
        Set keys = selector.selectedKeys();

        // Use a java.util.Iterator to loop through the selected keys
        for (Iterator i = keys.iterator(); i.hasNext();) {
            // Get the next SelectionKey in the set, and then remove it
            // from the set. It must be removed explicitly, or it will
            // be returned again by the next call to select().
            SelectionKey key = (SelectionKey) i.next();
            i.remove();

            // Check whether this key is the SelectionKey we got when
            // we registered the ServerSocketChannel.
            if (key == serverkey) {
                // Activity on the ServerSocketChannel means a client
                // is trying to connect to the server.
                if (key.isAcceptable()) {
                    // Accept the client connection, and obtain a
                    // SocketChannel to communicate with the client.
                    SocketChannel client = server.accept();

                    // Make sure we actually got a connection
                    if (client == null)
                        continue;

                    // Put the client channel in non-blocking mode.
                    client.configureBlocking(false);

                    // Now register the client channel with the Selector,
                    // specifying that we'd like to know when there is
                    // data ready to read on the channel.
                    SelectionKey clientkey = client.register(selector, SelectionKey.OP_READ);
                }
            } else {
                // If the key we got from the Set of keys is not the
                // ServerSocketChannel key, then it must be a key
                // representing one of the client connections.
                // Get the channel from the key.
                SocketChannel client = (SocketChannel) key.channel();

                // If we got here, it should mean that there is data to
                // be read from the channel, but we double-check here.
                if (!key.isReadable())
                    continue;

                // Now read bytes from the client. We assume that
                // we get all the client's bytes in one read operation
                client.read(body);

                // The data we read should be some kind of HTTP GET
                // request. We don't bother checking it however since
                // there is only one page of data we know how to return.
                body.clear();

                // Build an HTML document as our reponse.
                // The body of the document contains PrintService details
                StringBuffer response = new StringBuffer();
                response.append(
                        "<html><head><title>Printer Status</title></head>" + "<body><h1>Printer Status</h1>");
                for (int s = 0; s < services.length; s++) {
                    PrintService service = services[s];
                    response.append("<h2>").append(service.getName()).append("</h2><table>");
                    Attribute[] attrs = service.getAttributes().toArray();
                    for (int a = 0; a < attrs.length; a++) {
                        Attribute attr = attrs[a];
                        response.append("<tr><td>").append(attr.getName()).append("</td><td>").append(attr)
                                .append("</tr>");
                    }
                    response.append("</table>");
                }
                response.append("</body></html>\r\n");

                // Encode the response into the body ByteBuffer
                encoder.reset();
                encoder.encode(CharBuffer.wrap(response), body, true);
                encoder.flush(body);

                body.flip(); // Prepare the body buffer to be drained
                // While there are bytes left to write
                while (body.hasRemaining()) {
                    // Write both header and body buffers
                    client.write(buffers);
                }
                buffers[0].flip(); // Prepare header buffer for next write
                body.clear(); // Prepare body buffer for next read

                // Once we've sent our response, we have no more interest
                // in the client channel or its SelectionKey
                client.close(); // Close the channel.
                key.cancel(); // Tell Selector to stop monitoring it.
            }
        }
    }
}

From source file:org.cloudata.core.commitlog.FileTransferThread.java

public void run() {
    SocketChannel socketChannel = null;

    try {/*from  www.j  a  v a2s  .c o m*/
        if (selector.select(5000) > 0) {
            Iterator<SelectionKey> iter = selector.selectedKeys().iterator();

            while (iter.hasNext()) {
                SelectionKey key = iter.next();
                if (key.isValid() && key.isAcceptable()) {
                    socketChannel = ssc.accept();

                    transfer(channelList, socketChannel);
                }

                iter.remove();
            }
        } else {
            LOG.warn("No responses from client asking to transfter file for 5 sec");
        }
    } catch (IOException e) {
        LOG.warn("transfering file is fail", e);
    } finally {
        if (socketChannel != null) {
            try {
                socketChannel.socket().close();
                socketChannel.close();
            } catch (IOException e) { /* ignored */
            }
        }
    }

    LOG.debug("File transfer thread is done");
}

From source file:net.sf.cindy.impl.SimpleEventGenerator.java

protected void processKey(SelectionKey key) {
    SessionSpi session = (SessionSpi) key.attachment();

    if (key.isAcceptable())
        session.onEvent(Constants.EV_ACCEPTABLE, null);
    if (key.isConnectable())
        session.onEvent(Constants.EV_CONNECTABLE, null);
    if (key.isValid() && key.isReadable())
        session.onEvent(Constants.EV_READABLE, null);
    if (key.isValid() && key.isWritable())
        session.onEvent(Constants.EV_WRITABLE, null);
}

From source file:org.apache.catalina.cluster.tcp.ReplicationListener.java

public void listen() throws Exception {
    doListen = true;/*ww w .  j  a  v a  2 s. c  om*/
    // allocate an unbound server socket channel
    ServerSocketChannel serverChannel = ServerSocketChannel.open();
    // Get the associated ServerSocket to bind it with
    ServerSocket serverSocket = serverChannel.socket();
    // create a new Selector for use below
    Selector selector = Selector.open();
    // set the port the server channel will listen to
    serverSocket.bind(new InetSocketAddress(bind, port));
    // set non-blocking mode for the listening socket
    serverChannel.configureBlocking(false);
    // register the ServerSocketChannel with the Selector
    serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    while (doListen) {
        // this may block for a long time, upon return the
        // selected set contains keys of the ready channels
        try {

            //System.out.println("Selecting with timeout="+timeout);
            int n = selector.select(timeout);
            //System.out.println("select returned="+n);
            if (n == 0) {
                continue; // nothing to do
            }
            // get an iterator over the set of selected keys
            Iterator it = selector.selectedKeys().iterator();
            // look at each key in the selected set
            while (it.hasNext()) {
                SelectionKey key = (SelectionKey) it.next();
                // Is a new connection coming in?
                if (key.isAcceptable()) {
                    ServerSocketChannel server = (ServerSocketChannel) key.channel();
                    SocketChannel channel = server.accept();
                    registerChannel(selector, channel, SelectionKey.OP_READ,
                            new ObjectReader(channel, selector, callback));
                }
                // is there data to read on this channel?
                //System.out.println("key readable="+key.isReadable());
                if (key.isReadable()) {
                    readDataFromSocket(key);
                } else {
                    //System.out.println("This shouldn't get called");
                    key.interestOps(key.interestOps() & (~key.OP_WRITE));
                }

                // remove key from selected set, it's been handled
                it.remove();
            }
            //System.out.println("Done with loop");
        } catch (java.nio.channels.CancelledKeyException nx) {
            log.warn("Replication client disconnected, error when polling key. Ignoring client.");
        } catch (Exception x) {
            log.error("Unable to process request in ReplicationListener", x);
        }

    } //while
    serverChannel.close();
    selector.close();
}