@Override public boolean isMute() { return key.isValid() && (key.interestOps() & SelectionKey.OP_READ) == 0; }
private void eventLoop() throws IOException { while (true) { // honor interrupt request if (Thread.interrupted()) { break; } // honor any pending commands first processPendingCommands(); /* * Synchronous event de-multiplexing happens here, this is blocking call which returns when it is possible to * initiate non-blocking operation on any of the registered channels. */ selector.select(); /* * Represents the events that have occurred on registered handles. */ Set<SelectionKey> keys = selector.selectedKeys(); Iterator<SelectionKey> iterator = keys.iterator(); while (iterator.hasNext()) { SelectionKey key = iterator.next(); if (!key.isValid()) { iterator.remove(); continue; } processKey(key); } keys.clear(); } }
while (it.hasNext()) { SelectionKey sk = (SelectionKey) it.next(); ServerConnection sc = (ServerConnection) sk.attachment(); if (sc == null) { continue; if (tmpsk.isValid() && tmpsk.isReadable()) { } else if (tmpsk.isValid() && tmpsk.isWritable()) { } else if (!tmpsk.isValid()) { tmpsk.cancel(); this.tmpSel.selectNow(); // clear canceled key
Object a = key.attachment(); try { if (!key.isValid() || key.channel().keyFor(newSelectorTuple.unwrappedSelector) != null) { continue; int interestOps = key.interestOps(); key.cancel(); SelectionKey newKey = key.channel().register(newSelectorTuple.unwrappedSelector, interestOps, a); if (a instanceof AbstractNioChannel) {
int count = _selector.select(SELECTOR_LOOP_DELAY); if (count > 0) { Set<SelectionKey> selected = _selector.selectedKeys(); for (SelectionKey key : all) { try { Object att = key.attachment(); if (!(att instanceof NTCPConnection)) continue; // to the next con if ((!key.isValid()) && (!((SocketChannel)key.channel()).isConnectionPending()) && con.getTimeSinceCreated(now) > 2 * NTCPTransport.ESTABLISH_TIMEOUT) { if (_log.shouldLog(Log.INFO)) ((key.interestOps() & SelectionKey.OP_WRITE) == 0) ) { key.interestOps(SelectionKey.OP_WRITE | key.interestOps()); failsafeWrites++; for (SelectionKey key : keys) { try { Object att = key.attachment(); if (att instanceof ServerSocketChannel) { ServerSocketChannel chan = (ServerSocketChannel)att;
@Override public void run() { final Selector selector = this.selector; for (;;) { ++connectCount; try { selector.select(1000L); connect(selector); Set<SelectionKey> keys = selector.selectedKeys(); try { for (SelectionKey key : keys) { Object att = key.attachment(); if (att != null && key.isValid() && key.isConnectable()) { finishConnect(key, att); } else { key.cancel(); } } } finally { keys.clear(); } } catch (Throwable e) { LOGGER.warn(name, e); } } }
/** * Execute a write operation * @param key the selectionkey to write on * @throws IOException if an error happened during batch */ private void doWrite(SelectionKey key) throws IOException { WebSocketImpl conn = (WebSocketImpl) key.attachment(); if( SocketChannelIOHelper.batch( conn, conn.getChannel() ) ) { if( key.isValid() ) { key.interestOps(SelectionKey.OP_READ); } } }
@Override public void run() { if (key != null && key.isValid()) { SocketChannel channel = (SocketChannel) key.channel(); Beat beat = (Beat) key.attachment(); if (channel.isConnected()) { return; } try { channel.finishConnect(); } catch (Exception ignore) { } try { beat.finishCheck(false, false, beat.getTask().getCheckRTNormalized() * 2, "tcp:timeout"); key.cancel(); key.channel().close(); } catch (Exception ignore) { } } } }
select.select(5000); Set<SelectionKey> keys = select.selectedKeys(); for (SelectionKey k : keys) { if (!k.isValid()) continue; if (k.isAcceptable() && k.channel() == socks) { SocksClient cl = clients.get(i); try { if (k.channel() == cl.client) // from client (e.g. socks client) cl.newClientData(select); else if (k.channel() == cl.remote) { // from server client is connected to (e.g. website) cl.newRemoteData();
@Override public void run() { final Selector selector = this.selector; for (;;) { ++acceptCount; try { selector.select(1000L); Set<SelectionKey> keys = selector.selectedKeys(); try { for (SelectionKey key : keys) { if (key.isValid() && key.isAcceptable()) { accept(); } else { key.cancel(); } } } finally { keys.clear(); } } catch (Throwable e) { LOGGER.warn(getName(), e); } } }
for (SelectionKey key : oldSelector.selectedKeys()) { if (!key.isValid() && key.readyOps() == 0) continue; SelectableChannel channel = key.channel(); Object attachment = key.attachment();
@Override public void tryRegisterWriteOperation(Selector selector) { for (Entry<SocketChannel, ConcurrentLinkedQueue<ByteBuffer>> entry : channels.entrySet()) { if (!entry.getValue().isEmpty()) { for (SelectionKey key : selector.keys()) { if (key.channel() == entry.getKey() && key.isValid()) { key.interestOps(key.interestOps() | SelectionKey.OP_WRITE); break; } } } } }
private static void processConnectTimeout(Set<SelectionKey> keys, long currentTimeNanos) { for (SelectionKey k: keys) { if (!k.isValid()) { // Comment the close call again as it gave us major problems // with ClosedChannelExceptions. // // See: // * https://github.com/netty/netty/issues/142 // * https://github.com/netty/netty/issues/138 // // close(k); continue; } NioClientSocketChannel ch = (NioClientSocketChannel) k.attachment(); if (ch.connectDeadlineNanos > 0 && currentTimeNanos >= ch.connectDeadlineNanos) { // Create a new ConnectException everytime and not cache it as otherwise we end up with // using the wrong remoteaddress in the ConnectException message. // // See https://github.com/netty/netty/issues/2713 ConnectException cause = new ConnectTimeoutException("connection timed out: " + ch.requestedRemoteAddress); ch.connectFuture.setFailure(cause); fireExceptionCaught(ch, cause); ch.worker.close(ch, succeededFuture(ch)); } } }
if (isClosed()) break; Set<SelectionKey> keys = nioEventLoopAdapter.getSelector().selectedKeys(); try { for (SelectionKey key : keys) { if (!key.isValid()) continue; int readyOps = key.readyOps(); write(key); } else if ((readyOps & SelectionKey.OP_CONNECT) != 0) { Object att = key.attachment(); connectionEstablished(key, att); } else {
SelectionKey writeKey = null; if (this.selector.selectedKeys().contains(proxyKey) && proxyKey.isValid() && proxyKey.isWritable()) { writeChannel = this.proxy; readChannel = this.client; writeKey = proxyKey; } else if (this.selector.selectedKeys().contains(clientKey) && clientKey.isValid() && clientKey.isWritable()) { writeChannel = this.client; readChannel = this.proxy;
private void select() { try { selector.select(); Set<SelectionKey> selected = selector.selectedKeys(); ArrayList<SelectionKey> selectedList = new ArrayList<SelectionKey>(selected); Collections.shuffle(selectedList); Iterator<SelectionKey> selectedKeys = selectedList.iterator(); while(!stopped && selectedKeys.hasNext()) { SelectionKey key = selectedKeys.next(); selected.remove(key); if (!key.isValid()) { cleanupSelectionKey(key); continue; } if (key.isReadable() || key.isWritable()) { handleIO(key); } else { LOG.warn("Unexpected ops in select " + key.readyOps()); } } } catch (IOException e) { LOG.warn("Ignoring IOException while selecting", e); } }
@Override public boolean isMute() { return key.isValid() && (key.interestOps() & SelectionKey.OP_READ) == 0; }
Object a = key.attachment(); try { if (!key.isValid() || key.channel().keyFor(newSelectorTuple.unwrappedSelector) != null) { continue; int interestOps = key.interestOps(); key.cancel(); SelectionKey newKey = key.channel().register(newSelectorTuple.unwrappedSelector, interestOps, a); if (a instanceof AbstractNioChannel) {