How to use

awaitUninterruptibly

method

in

org.jboss.netty.channel.ChannelFuture

@Override
public void disableRecv() {
  disableRecvNoWait().awaitUninterruptibly();
}

 @Override
 public void close(ChannelFuture resource)
 {
  log.trace("Closing");
  resource.awaitUninterruptibly().getChannel().close();
 }
}

/**
 * close a channel
 */
protected void closeChannel(Channel channel) {
  MessageDecoder.removeTransmitHistogram(channel);
  channel.close().awaitUninterruptibly();
  allChannels.remove(channel);
}

public synchronized void close()
{
  if (isClosed)
    return;
  ChannelFuture closeFuture = channel.close();
  closeFuture.awaitUninterruptibly();
  if (!closeFuture.isSuccess())
  {
    System.err.println("TCP channel " + channel.getId()
        + " did not close successfully");
  }
  isClosed = true;
}

public ChannelGroupFuture disconnect() {
  Map<Integer, ChannelFuture> futures =
    new LinkedHashMap<Integer, ChannelFuture>(size());
  for (Channel c: serverChannels.values()) {
    futures.put(c.getId(), c.disconnect().awaitUninterruptibly());
  }
  for (Channel c: nonServerChannels.values()) {
    futures.put(c.getId(), c.disconnect());
  }
  return new DefaultChannelGroupFuture(this, futures);
}

public ChannelGroupFuture close() {
  Map<Integer, ChannelFuture> futures =
    new LinkedHashMap<Integer, ChannelFuture>(size());
  for (Channel c: serverChannels.values()) {
    futures.put(c.getId(), c.close().awaitUninterruptibly());
  }
  for (Channel c: nonServerChannels.values()) {
    futures.put(c.getId(), c.close());
  }
  return new DefaultChannelGroupFuture(this, futures);
}

public ChannelGroupFuture setInterestOps(int interestOps) {
  Map<Integer, ChannelFuture> futures =
    new LinkedHashMap<Integer, ChannelFuture>(size());
  for (Channel c: serverChannels.values()) {
    futures.put(c.getId(), c.setInterestOps(interestOps).awaitUninterruptibly());
  }
  for (Channel c: nonServerChannels.values()) {
    futures.put(c.getId(), c.setInterestOps(interestOps));
  }
  return new DefaultChannelGroupFuture(this, futures);
}

public ChannelGroupFuture unbind() {
  Map<Integer, ChannelFuture> futures =
    new LinkedHashMap<Integer, ChannelFuture>(size());
  for (Channel c: serverChannels.values()) {
    futures.put(c.getId(), c.unbind().awaitUninterruptibly());
  }
  for (Channel c: nonServerChannels.values()) {
    futures.put(c.getId(), c.unbind());
  }
  return new DefaultChannelGroupFuture(this, futures);
}

public ChannelGroupFuture setReadable(boolean readable) {
  Map<Integer, ChannelFuture> futures =
    new LinkedHashMap<Integer, ChannelFuture>(size());
  for (Channel c: serverChannels.values()) {
    futures.put(c.getId(), c.setReadable(readable).awaitUninterruptibly());
  }
  for (Channel c: nonServerChannels.values()) {
    futures.put(c.getId(), c.setReadable(readable));
  }
  return new DefaultChannelGroupFuture(this, futures);
}

@Override
public boolean isGood(ChannelFuture resource)
{
 Channel channel = resource.awaitUninterruptibly().getChannel();
 boolean isSuccess = resource.isSuccess();
 boolean isConnected = channel.isConnected();
 boolean isOpen = channel.isOpen();
 if (log.isTraceEnabled()) {
  log.trace("isGood = isSucess[%s] && isConnected[%s] && isOpen[%s]", isSuccess, isConnected, isOpen);
 }
 return isSuccess && isConnected && isOpen;
}

@Override
public void disconnect() {
  super.disconnect();
  if (channel.isOpen()) {
    channel.close().awaitUninterruptibly();
  }
  WorldProvider worldProvider = CoreRegistry.get(WorldProvider.class);
  if (worldProvider != null) {
    worldProvider.unregisterListener(this);
  }
}

/**
 * Creates a new channel which is bound to the specified local address. This operation will block until
 * the channel is bound.
 *
 * @return a new bound channel which accepts incoming connections
 *
 * @throws ChannelException
 *         if failed to create a new channel and
 *                      bind it to the local address
 */
public Channel bind(final SocketAddress localAddress) {
  ChannelFuture future = bindAsync(localAddress);
  // Wait for the future.
  future.awaitUninterruptibly();
  if (!future.isSuccess()) {
    future.getChannel().close().awaitUninterruptibly();
    throw new ChannelException("Failed to bind to: " + localAddress, future.getCause());
  }
  return future.getChannel();
}

@Override
public void shutdown() {
  LOG.info("shutdown called " + localAddress);
  if (login != null) {
    login.shutdown();
  }
  // null if factory never started
  if (parentChannel != null) {
    parentChannel.close().awaitUninterruptibly();
    closeAll();
    allChannels.close().awaitUninterruptibly();
    bootstrap.releaseExternalResources();
  }
  if (zkServer != null) {
    zkServer.shutdown();
  }
  synchronized(this) {
    killed = true;
    notifyAll();
  }
}

public void stop() {
  super.stop();
  if (this.serverChannel != null) {
    this.serverChannel.close().awaitUninterruptibly(1000);
  }
  // close sockets explicitly to reduce socket channel hung in complicated
  // network environment.
  if (this.childGroups != null) {
    this.childGroups.close().awaitUninterruptibly(5000);
  }
  if (this.bootstrap != null) {
    this.bootstrap.releaseExternalResources();
  }
  if (embeddedServer.isStart()) {
    embeddedServer.stop();
  }
}

} catch (InterruptedException e) {
  connectCheck.cancel();
  connectCheck.getChannel().getCloseFuture().awaitUninterruptibly();
  factory.releaseExternalResources();
  throw e;
  connectCheck.getChannel().getCloseFuture().awaitUninterruptibly();
  factory.releaseExternalResources();
  return new JoinStatusImpl("Failed to connect to server - " + connectCheck.getCause().getMessage());

future.awaitUninterruptibly();
if (!future.isSuccess()) {
  future.getChannel().close().awaitUninterruptibly();
  throw new ChannelException("Failed to bind to: " + localAddress, future.getCause());

ChannelFuture future = bootstrap.connect(getConnectAddress());
try {
  boolean ret = future.awaitUninterruptibly(getConnectTimeout(), TimeUnit.MILLISECONDS);

ChannelFuture future = bootstrap.connect(getConnectAddress());
try {
  boolean ret = future.awaitUninterruptibly(getConnectTimeout(), TimeUnit.MILLISECONDS);

boolean result = channelFuture.awaitUninterruptibly(timeout, TimeUnit.MILLISECONDS);
boolean success = channelFuture.isSuccess();

boolean result = writeFuture.awaitUninterruptibly(timeout, TimeUnit.MILLISECONDS);