Java Code Examples for java.nio.channels.SelectionKey#OP_ACCEPT

@Override
public void update(Selectable selectable) {
    if (selectable.getChannel() != null) {
        int interestedOps = 0;
        if (selectable.getChannel() instanceof SocketChannel &&
                ((SocketChannel)selectable.getChannel()).isConnectionPending()) {
            interestedOps |= SelectionKey.OP_CONNECT;
        } else {
            if (selectable.isReading()) {
                if (selectable.getChannel() instanceof ServerSocketChannel) {
                    interestedOps |= SelectionKey.OP_ACCEPT;
                } else {
                    interestedOps |= SelectionKey.OP_READ;
                }
            }
            if (selectable.isWriting()) interestedOps |= SelectionKey.OP_WRITE;
        }
        SelectionKey key = selectable.getChannel().keyFor(selector);
        key.interestOps(interestedOps);
    }
}
 

protected void startNIOServer() throws Exception {
    SelectableChannel server = null;
    int interestKey;

    //1. Start reactor service
    selectorManager.start();

    //2. Start server on the specified port
    if (this.udpMode) {
        server = DatagramChannel.open();
        ((DatagramChannel) server).socket().bind(new InetSocketAddress(host, port));
        interestKey = SelectionKey.OP_READ;
    } else {
        server = ServerSocketChannel.open();
        ((ServerSocketChannel) server).socket().bind(new InetSocketAddress(host, port), 1024);
        interestKey = SelectionKey.OP_ACCEPT;

    }

    server.configureBlocking(false);

    //3. Choose one reactor to handle NIO event
    selectorManager.getReactor(0).registerChannel(server, interestKey);
    System.out.println("INFO: NAMI Server started on port " + String.valueOf(port) + "...");

}
 

String printSelectionOps(SelectionKey key) {
    StringBuffer sb=new StringBuffer();
    if ((key.readyOps() & SelectionKey.OP_ACCEPT) !=0)
        sb.append("OP_ACCEPT ");
    if ((key.readyOps() & SelectionKey.OP_CONNECT) !=0)
        sb.append("OP_CONNECT ");
    if ((key.readyOps() & SelectionKey.OP_READ) !=0)
        sb.append("OP_READ ");
    if ((key.readyOps() & SelectionKey.OP_WRITE) !=0)
        sb.append("OP_WRITE ");
    return sb.toString();
}
 

String printSelectionOps(SelectionKey key) {
    StringBuffer sb=new StringBuffer();
    if ((key.readyOps() & SelectionKey.OP_ACCEPT) !=0)
        sb.append("OP_ACCEPT ");
    if ((key.readyOps() & SelectionKey.OP_CONNECT) !=0)
        sb.append("OP_CONNECT ");
    if ((key.readyOps() & SelectionKey.OP_READ) !=0)
        sb.append("OP_READ ");
    if ((key.readyOps() & SelectionKey.OP_WRITE) !=0)
        sb.append("OP_WRITE ");
    return sb.toString();
}
 

/**
 * @tests java.nio.channels.SelectionKey#attachment()
 */
public void test_attachment() {
    MockSelectionKey mockSelectionKey = new MockSelectionKey(SelectionKey.OP_ACCEPT);
    assertNull(mockSelectionKey.attachment());
    Object o = new Object();
    mockSelectionKey.attach(o);
    assertSame(o, mockSelectionKey.attachment());
}
 

private static void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
    final NioUnsafe unsafe = ch.unsafe();
    if (!k.isValid()) {
        // close the channel if the key is not valid anymore
        unsafe.close(unsafe.voidPromise());
        return;
    }

    try {
        int readyOps = k.readyOps();
        // Also check for readOps of 0 to workaround possible JDK bug which may otherwise lead
        // to a spin loop
        if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
            unsafe.read();
            if (!ch.isOpen()) {
                // Connection already closed - no need to handle write.
                return;
            }
        }
        if ((readyOps & SelectionKey.OP_WRITE) != 0) {
            // Call forceFlush which will also take care of clear the OP_WRITE once there is nothing left to write
            ch.unsafe().forceFlush();
        }
        if ((readyOps & SelectionKey.OP_CONNECT) != 0) {
            // remove OP_CONNECT as otherwise Selector.select(..) will always return without blocking
            // See https://github.com/netty/netty/issues/924
            int ops = k.interestOps();
            ops &= ~SelectionKey.OP_CONNECT;
            k.interestOps(ops);

            unsafe.finishConnect();
        }
    } catch (CancelledKeyException ignored) {
        unsafe.close(unsafe.voidPromise());
    }
}
 

public void registerForEvent(EventHandler eventHandler)
{
    if (orb.transportDebugFlag) {
        dprint(".registerForEvent: " + eventHandler);
    }

    if (isClosed()) {
        if (orb.transportDebugFlag) {
            dprint(".registerForEvent: closed: " + eventHandler);
        }
        return;
    }

    if (eventHandler.shouldUseSelectThreadToWait()) {
        synchronized (deferredRegistrations) {
            deferredRegistrations.add(eventHandler);
        }
        if (! selectorStarted) {
            startSelector();
        }
        selector.wakeup();
        return;
    }

    switch (eventHandler.getInterestOps()) {
    case SelectionKey.OP_ACCEPT :
        createListenerThread(eventHandler);
        break;
    case SelectionKey.OP_READ :
        createReaderThread(eventHandler);
        break;
    default:
        if (orb.transportDebugFlag) {
            dprint(".registerForEvent: default: " + eventHandler);
        }
        throw new RuntimeException(
            "SelectorImpl.registerForEvent: unknown interest ops");
    }
}
 

private static boolean awaitOp(Selector selector, SelectionKey key, int op) throws IOException {
    long end = System.currentTimeMillis() + SELECTION_TIMEOUT_MS;
    boolean selected = false;
    while (!selected) {
        // Check timeout
        long remaining = end - System.currentTimeMillis();
        if (remaining < 0) {
            break;
        }

        // Select up to remaining millis
        selector.select(remaining);

        // Handle op if possible
        switch (op) {
        case SelectionKey.OP_READ:
            selected |= key.isReadable();
            break;
        case SelectionKey.OP_ACCEPT:
            selected |= key.isAcceptable();
            break;
        case SelectionKey.OP_WRITE:
            selected |= key.isWritable();
            break;
        case SelectionKey.OP_CONNECT:
            selected |= key.isConnectable();
            break;
        }
    }
    return selected;
}
 

@Override
public void translateAndSetInterestOps(int ops, SelectionKeyImpl sk) {
    int newOps = 0;

    /* Translate ops */
    if ((ops & SelectionKey.OP_ACCEPT) != 0)
        newOps |= Net.POLLIN;
    /* Place ops into pollfd array */
    sk.selector.putEventOps(sk, newOps);

}
 

/**
 * Translates native poll revent ops into a ready operation ops
 */
private boolean translateReadyOps(int ops, int initialOps,
                                 SelectionKeyImpl sk) {
    int intOps = sk.nioInterestOps();
    int oldOps = sk.nioReadyOps();
    int newOps = initialOps;

    if ((ops & Net.POLLNVAL) != 0) {
        /* This should only happen if this channel is pre-closed while a
         * selection operation is in progress
         * ## Throw an error if this channel has not been pre-closed */
        return false;
    }

    if ((ops & (Net.POLLERR | Net.POLLHUP)) != 0) {
        newOps = intOps;
        sk.nioReadyOps(newOps);
        return (newOps & ~oldOps) != 0;
    }

    if (((ops & Net.POLLIN) != 0) &&
        ((intOps & SelectionKey.OP_ACCEPT) != 0))
            newOps |= SelectionKey.OP_ACCEPT;

    sk.nioReadyOps(newOps);
    return (newOps & ~oldOps) != 0;
}
 

/**
 * Translates native poll revent ops into a ready operation ops
 */
private boolean translateReadyOps(int ops, int initialOps,
                                 SelectionKeyImpl sk) {
    int intOps = sk.nioInterestOps();
    int oldOps = sk.nioReadyOps();
    int newOps = initialOps;

    if ((ops & Net.POLLNVAL) != 0) {
        /* This should only happen if this channel is pre-closed while a
         * selection operation is in progress
         * ## Throw an error if this channel has not been pre-closed */
        return false;
    }

    if ((ops & (Net.POLLERR | Net.POLLHUP)) != 0) {
        newOps = intOps;
        sk.nioReadyOps(newOps);
        return (newOps & ~oldOps) != 0;
    }

    if (((ops & Net.POLLIN) != 0) &&
        ((intOps & SelectionKey.OP_ACCEPT) != 0))
            newOps |= SelectionKey.OP_ACCEPT;

    sk.nioReadyOps(newOps);
    return (newOps & ~oldOps) != 0;
}
 

/**
 * Create a new instance using the given {@link ServerSocketChannel}.
 */
public NioServerSocketChannel(ServerSocketChannel channel) {
    super(null, channel, SelectionKey.OP_ACCEPT);
    config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}
 

public void unregisterForEvent(EventHandler eventHandler)
{
    if (orb.transportDebugFlag) {
        dprint(".unregisterForEvent: " + eventHandler);
    }

    if (isClosed()) {
        if (orb.transportDebugFlag) {
            dprint(".unregisterForEvent: closed: " + eventHandler);
        }
        return;
    }

    if (eventHandler.shouldUseSelectThreadToWait()) {
        SelectionKey selectionKey ;
        synchronized(deferredRegistrations) {
            selectionKey = eventHandler.getSelectionKey();
        }
        if (selectionKey != null) {
            selectionKey.cancel();
        }
        if (selector != null) {
            selector.wakeup();
        }
        return;
    }

    switch (eventHandler.getInterestOps()) {
    case SelectionKey.OP_ACCEPT :
        destroyListenerThread(eventHandler);
        break;
    case SelectionKey.OP_READ :
        destroyReaderThread(eventHandler);
        break;
    default:
        if (orb.transportDebugFlag) {
            dprint(".unregisterForEvent: default: " + eventHandler);
        }
        throw new RuntimeException(
            "SelectorImpl.uregisterForEvent: unknown interest ops");
    }
}
 

@Override
public int calcInterestOps() {
	return SelectionKey.OP_ACCEPT;
}
 

public int getInterestOps()
{
    return SelectionKey.OP_ACCEPT;
}
 

public void unregisterForEvent(EventHandler eventHandler)
{
    if (orb.transportDebugFlag) {
        dprint(".unregisterForEvent: " + eventHandler);
    }

    if (isClosed()) {
        if (orb.transportDebugFlag) {
            dprint(".unregisterForEvent: closed: " + eventHandler);
        }
        return;
    }

    if (eventHandler.shouldUseSelectThreadToWait()) {
        SelectionKey selectionKey ;
        synchronized(deferredRegistrations) {
            selectionKey = eventHandler.getSelectionKey();
        }
        if (selectionKey != null) {
            selectionKey.cancel();
        }
        if (selector != null) {
            selector.wakeup();
        }
        return;
    }

    switch (eventHandler.getInterestOps()) {
    case SelectionKey.OP_ACCEPT :
        destroyListenerThread(eventHandler);
        break;
    case SelectionKey.OP_READ :
        destroyReaderThread(eventHandler);
        break;
    default:
        if (orb.transportDebugFlag) {
            dprint(".unregisterForEvent: default: " + eventHandler);
        }
        throw new RuntimeException(
            "SelectorImpl.uregisterForEvent: unknown interest ops");
    }
}
 

public int getInterestOps()
{
    return SelectionKey.OP_ACCEPT;
}
 

/**
 * Returns an operation set identifying this channel's supported
 * operations.
 *
 * <P> SCTP server channels only support the accepting of new
 * associations, so this method returns
 * {@link java.nio.channels.SelectionKey#OP_ACCEPT}.
 *
 * @return  The valid-operation set
 */
@Override
public final int validOps() {
    return SelectionKey.OP_ACCEPT;
}
 

/**
 * Returns an operation set identifying this channel's supported
 * operations.
 *
 * <P> SCTP server channels only support the accepting of new
 * associations, so this method returns
 * {@link java.nio.channels.SelectionKey#OP_ACCEPT}.
 *
 * @return  The valid-operation set
 */
@Override
public final int validOps() {
    return SelectionKey.OP_ACCEPT;
}
 

/**
 * Returns an operation set identifying this channel's supported
 * operations.
 *
 * <P> SCTP server channels only support the accepting of new
 * associations, so this method returns
 * {@link java.nio.channels.SelectionKey#OP_ACCEPT}.
 *
 * @return  The valid-operation set
 */
@Override
public final int validOps() {
    return SelectionKey.OP_ACCEPT;
}