private void closeChannelAndReportException(Channel channel) { try { channel.close(); } catch (IOException e) { reportIOException(e); } }
public static void closeChannel(Channel channel) throws NetIOException { try { channel.close(); } catch (IOException e) { throw new NetIOException(e); } }
void finish(boolean close) throws BadDescriptorException, IOException { synchronized (refCounter) { // if refcount is at or below zero, we're no longer valid if (refCounter.get() <= 0) { throw new BadDescriptorException(); } // if channel is already closed, we're no longer valid if (!channel.isOpen()) { throw new BadDescriptorException(); } // otherwise decrement and possibly close as normal if (close) { int count = refCounter.decrementAndGet(); if (DEBUG) LOG.info("Descriptor for fileno {} refs: {}", internalFileno, count); if (count <= 0) { // if we're the last referrer, close the channel try { channel.close(); } finally { unregisterDescriptor(internalFileno); } } } } }
/** * Closes the channel (safe). * * <p>This method tries to close the given channel and if an IOException occurs a message with the * level {@link Level#FINE} is logged. It's safe to pass a <code>null</code> reference for the * argument. * * @param channel the channel that should be closed. */ public static void close(Channel channel) { if (channel != null) { try { channel.close(); } catch (IOException x) { logCloseFailedWarningMessage(Channel.class, channel.getClass(), x); } } }
static void closeAndWait(@Nullable Channel channel, Logger log) throws IOException { if (channel != null) { channel.close(); try { Thread.sleep(500); } catch (InterruptedException e) { log.warn("", e); } } }
/** * Close the channel * * @param channel the channel to close */ public static void close(Channel channel) { if (channel != null) { try { channel.close(); } catch (IOException e) { // Nothing to do } } }
public static void cleanUp(Channel channel) { try { if (channel != null) { channel.close(); } } catch (Exception e) { if (_log.isWarnEnabled()) { _log.warn(e, e); } } }
void cleanupChannel(final Channel ch, final Runnable callback) { if (null == ch) { // not expected logger.warn("null channel passed to cleanupChannel()", new Throwable()); return; } if (Thread.currentThread() != this) { if (logger.isDebugEnabled()) { logger.debug("queue'ing channel close operation"); } addSelectorTask( new Runnable() { @Override public void run() { CommThread.this.cleanupChannel(ch, callback); } }); return; } try { if (ch instanceof SelectableChannel) { SelectableChannel sc = (SelectableChannel) ch; try { SelectionKey sk = sc.keyFor(selector); if (sk != null) { sk.attach(null); sk.cancel(); } } catch (Exception e) { logger.warn("Exception trying to clear selection key", e); } } if (ch instanceof SocketChannel) { SocketChannel sc = (SocketChannel) ch; Socket s = sc.socket(); if (null != s) { synchronized (s) { if (s.isConnected()) { try { if (!s.isOutputShutdown()) { s.shutdownOutput(); } } catch (Exception e) { logger.warn("Exception trying to shutdown socket output: " + e.getMessage()); } try { if (!s.isClosed()) { s.close(); } } catch (Exception e) { logger.warn("Exception trying to close() socket: " + e.getMessage()); } } } } } else if (ch instanceof ServerSocketChannel) { ServerSocketChannel ssc = (ServerSocketChannel) ch; try { ssc.close(); } catch (Exception e) { logger.warn("Exception trying to close() server socket" + e.getMessage()); } } try { ch.close(); } catch (Exception e) { logger.warn("Exception trying to close channel", e); } } catch (Exception e) { // this is just a catch all to make sure that no exceptions will be thrown by this method, // please do not remove logger.error("Unhandled exception in cleanupChannel()", e); } finally { try { if (callback != null) { callback.run(); } } catch (Throwable t) { logger.error("Unhandled exception in cleanupChannel callback.", t); } } }
@Override public void run() { // loop while any socket is open while (incoming.isOpen() || !peers.isEmpty()) { try { // wait on selector selector.select(10000); // Handle all ready channels Set<SelectionKey> selected = selector.selectedKeys(); for (SelectionKey k : selected.toArray(new SelectionKey[0])) { selected.remove(k); // We're handling it if (!k.isValid()) continue; // Invalid? Channel c = k.channel(); if (c.equals(incoming)) { acceptIncomingPeer(); } else if (new_sockets.contains(c)) { processNewSocket((SocketChannel) c); } else if (new_peers.containsKey(c)) { processNewPeer((SocketChannel) c); } else if (peers.containsKey(c)) { processPeerMessage((SocketChannel) c); } else { System.err.println("Tried to process unknown socket."); k.cancel(); // If we don't know it now, we'll probably never know it. c.close(); } } // Check for closed sockets for (SocketChannel socket : peers.keySet().toArray(new SocketChannel[0])) { if (!socket.isOpen()) { socket.keyFor(selector).cancel(); Peer peer = peers.get(socket); peers.remove(socket); sockets.remove(peer); if (listener != null) listener.dropPeer(peer); // TODO: Reconnect, propose drop } } for (SocketChannel socket : new_sockets) { if (!socket.isOpen()) { socket.keyFor(selector).cancel(); new_sockets.remove(socket); } } for (SocketChannel socket : new_peers.keySet()) { if (!socket.isOpen()) { socket.keyFor(selector).cancel(); new_peers.remove(socket); // TODO: Retry? } else if (!socket.isRegistered()) { // Check for new sockets. socket.register(selector, SelectionKey.OP_READ); } } } catch (IOException e) { // TODO Handle this better. In mean time, just keep going. System.err.println(e); e.printStackTrace(); } } try { selector.close(); } catch (IOException e) { // Not much to do. e.printStackTrace(); } }