public Channel getActiveChannel() throws InterruptedException {
List<InetSocketAddress> addresses = m_descriptor.getRemoteAddresses();
if (!addresses.equals(m_addresses)) { // first time or addresses changed
m_addresses = addresses;
for (int i = 0; i < addresses.size(); i++) {
InetSocketAddress address = addresses.get(i);
ChannelFuture future = m_bootstrap.connect(address).sync();
if (future.isSuccess()) {
// close old channel
if (m_channel != null) {
m_channel.close();
}
// m_logger.info(String.format("Connected to %s server(%s:%s)", m_descriptor.getName(),
// address.getHostName(), address.getPort()));
m_channel = future.channel();
m_index = i;
break;
}
}
return m_channel;
} else {
// closed by peer
if (m_channel != null && m_channel.closeFuture().isSuccess()) {
// TODO
}
// try to recover connection to primary server
if (m_index > 0) {
if (m_primary == null) {
long now = System.currentTimeMillis();
if (m_lastCheckTime + m_failBackCheckInternal < now) {
InetSocketAddress address = m_addresses.get(m_index);
m_lastCheckTime = now;
m_primary = m_bootstrap.connect(address);
}
} else {
Channel channel = m_primary.channel();
if (channel.isOpen() && channel.isActive()) {
m_channel = channel;
m_index = 0;
}
}
}
if (m_channel != null && m_channel.isOpen() && m_channel.isActive()) {
return m_channel;
} else {
return null;
}
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable t) {
Channel ch = ctx.channel();
// Prevent recursion when the client close the connection during a write operation. In that
// scenario the sendError will be invoked, but will fail since the channel has already been
// closed
// For an unknown reason,
if (ch.attr(ATTACHMENT) != null
&& Error.class.isAssignableFrom(ch.attr(ATTACHMENT).get().getClass())) {
return;
}
Throwable cause = t.getCause();
if (cause instanceof TooLongFrameException) {
sendError(ctx, BAD_REQUEST, null);
return;
}
ch.attr(ATTACHMENT).set(new Error());
if (ch.isOpen()) {
sendError(ctx, INTERNAL_SERVER_ERROR, null);
}
if (ctx.channel().isActive()) {
sendError(ctx, INTERNAL_SERVER_ERROR, null);
}
}
protected void increaseCounter(Runnable task) {
if (!shouldCount(task)) {
return;
}
Settings settings = this.settings;
long maxChannelMemorySize = settings.maxChannelMemorySize;
int increment = settings.objectSizeEstimator.estimateSize(task);
if (task instanceof ChannelEventRunnable) {
ChannelEventRunnable eventTask = (ChannelEventRunnable) task;
eventTask.estimatedSize = increment;
Channel channel = eventTask.getEvent().getChannel();
long channelCounter = getChannelCounter(channel).addAndGet(increment);
// System.out.println("IC: " + channelCounter + ", " + increment);
if (maxChannelMemorySize != 0 && channelCounter >= maxChannelMemorySize && channel.isOpen()) {
if (channel.isReadable()) {
// System.out.println("UNREADABLE");
ChannelHandlerContext ctx = eventTask.getContext();
if (ctx.getHandler() instanceof ExecutionHandler) {
// readSuspended = true;
ctx.setAttachment(Boolean.TRUE);
}
channel.setReadable(false);
}
}
} else {
((MemoryAwareRunnable) task).estimatedSize = increment;
}
if (totalLimiter != null) {
totalLimiter.increase(increment);
}
}
protected void a(ChannelHandlerContext var1, Packet var2) throws Exception {
if (k.isOpen()) {
try {
var2.handle(m);
} catch (class_ko var4) {;
}
}
}
@Override
public void shutdown() {
notifyShutdown(Status.OK.withDescription("Channel requested transport to shut down"));
// Notifying of termination is automatically done when the channel closes.
if (channel != null && channel.isOpen()) {
channel.close();
}
}
@Override
public void close(Channel channel) throws Exception {
try {
if (channel.isOpen()) channel.close().sync();
} catch (InterruptedException e) {
logger.error("close channel Error ", e);
}
// 将channel移除
removeChannel(channel);
}
private void m() {
if ((k != null) && k.isOpen()) {
j.readLock().lock();
try {
while (!i.isEmpty()) {
class_ek.class_a_in_class_ek var1 = (class_ek.class_a_in_class_ek) i.poll();
this.a(var1.a, var1.b);
}
} finally {
j.readLock().unlock();
}
}
}
public void l() {
if ((k != null) && !k.isOpen()) {
if (!p) {
p = true;
if (j() != null) {
i().a(j());
} else if (i() != null) {
i().a(new class_fa("Disconnected"));
}
} else {
g.warn("handleDisconnection() called twice");
}
}
}
@Test
public void listenerExceptionShouldCloseConnection() throws Exception {
final Http2Headers headers = dummyHeaders();
doThrow(new RuntimeException("Fake Exception"))
.when(serverListener)
.onHeadersRead(
any(ChannelHandlerContext.class),
eq(3),
eq(headers),
eq(0),
eq((short) 16),
eq(false),
eq(0),
eq(false));
bootstrapEnv(1, 0, 1, 1);
// Create a latch to track when the close occurs.
final CountDownLatch closeLatch = new CountDownLatch(1);
clientChannel
.closeFuture()
.addListener(
new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
closeLatch.countDown();
}
});
// Create a single stream by sending a HEADERS frame to the server.
runInChannel(
clientChannel,
new Http2Runnable() {
@Override
public void run() {
http2Client
.encoder()
.writeHeaders(ctx(), 3, headers, 0, (short) 16, false, 0, false, newPromise());
}
});
// Wait for the server to create the stream.
assertTrue(serverSettingsAckLatch.await(5, SECONDS));
assertTrue(requestLatch.await(5, SECONDS));
// Wait for the close to occur.
assertTrue(closeLatch.await(5, SECONDS));
assertFalse(clientChannel.isOpen());
}
@Test
public void commandNotExecutedChannelClosesWhileFlush() throws Exception {
RedisCommands<String, String> connection = client.connect().sync();
RedisCommands<String, String> verificationConnection = client.connect().sync();
RedisChannelWriter<String, String> channelWriter =
getRedisChannelHandler(connection).getChannelWriter();
connection.set(key, "1");
assertThat(verificationConnection.get(key)).isEqualTo("1");
final CountDownLatch block = new CountDownLatch(1);
AsyncCommand<String, String, Object> command =
new AsyncCommand<String, String, Object>(
new Command<>(
CommandType.INCR, new IntegerOutput(CODEC), new CommandArgs<>(CODEC).addKey(key))) {
@Override
public void encode(ByteBuf buf) {
try {
block.await();
} catch (InterruptedException e) {
}
super.encode(buf);
}
};
channelWriter.write(command);
Channel channel = getChannel(getRedisChannelHandler(connection));
channel.unsafe().disconnect(channel.newPromise());
assertThat(channel.isOpen()).isFalse();
assertThat(command.isCancelled()).isFalse();
assertThat(command.isDone()).isFalse();
block.countDown();
assertThat(command.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(command.isCancelled()).isFalse();
assertThat(command.isDone()).isTrue();
assertThat(verificationConnection.get(key)).isEqualTo("1");
assertThat(getQueue(getRedisChannelHandler(connection))).isEmpty();
assertThat(getCommandBuffer(getRedisChannelHandler(connection))).isEmpty();
connection.close();
}
@Test
public void commandRetriedChannelClosesWhileFlush() throws Exception {
assumeTrue(Version.identify().get("netty-transport").artifactVersion().startsWith("4.0.2"));
RedisCommands<String, String> connection = client.connect().sync();
RedisCommands<String, String> verificationConnection = client.connect().sync();
RedisChannelWriter<String, String> channelWriter =
getRedisChannelHandler(connection).getChannelWriter();
connection.set(key, "1");
assertThat(verificationConnection.get(key)).isEqualTo("1");
final CountDownLatch block = new CountDownLatch(1);
ConnectionWatchdog connectionWatchdog =
Connections.getConnectionWatchdog(connection.getStatefulConnection());
AsyncCommand<String, String, Object> command = getBlockOnEncodeCommand(block);
channelWriter.write(command);
connectionWatchdog.setReconnectSuspended(true);
Channel channel = getChannel(getRedisChannelHandler(connection));
channel.unsafe().disconnect(channel.newPromise());
assertThat(channel.isOpen()).isFalse();
assertThat(command.isCancelled()).isFalse();
assertThat(command.isDone()).isFalse();
block.countDown();
assertThat(command.await(2, TimeUnit.SECONDS)).isFalse();
connectionWatchdog.setReconnectSuspended(false);
connectionWatchdog.scheduleReconnect();
assertThat(command.await(2, TimeUnit.SECONDS)).isTrue();
assertThat(command.isCancelled()).isFalse();
assertThat(command.isDone()).isTrue();
assertThat(verificationConnection.get(key)).isEqualTo("2");
assertThat(getQueue(getRedisChannelHandler(connection))).isEmpty();
assertThat(getCommandBuffer(getRedisChannelHandler(connection))).isEmpty();
connection.close();
verificationConnection.close();
}
@Test
public void nonHttp2ExceptionInPipelineShouldNotCloseConnection() throws Exception {
bootstrapEnv(1, 1, 1, 1);
// Create a latch to track when the close occurs.
final CountDownLatch closeLatch = new CountDownLatch(1);
clientChannel
.closeFuture()
.addListener(
new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
closeLatch.countDown();
}
});
// Create a single stream by sending a HEADERS frame to the server.
final Http2Headers headers = dummyHeaders();
runInChannel(
clientChannel,
new Http2Runnable() {
@Override
public void run() {
http2Client
.encoder()
.writeHeaders(ctx(), 3, headers, 0, (short) 16, false, 0, false, newPromise());
}
});
// Wait for the server to create the stream.
assertTrue(serverSettingsAckLatch.await(5, SECONDS));
assertTrue(requestLatch.await(5, SECONDS));
// Add a handler that will immediately throw an exception.
clientChannel
.pipeline()
.addFirst(
new ChannelHandlerAdapter() {
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
throw new RuntimeException("Fake Exception");
}
});
// The close should NOT occur.
assertFalse(closeLatch.await(5, SECONDS));
assertTrue(clientChannel.isOpen());
}
private AtomicLong getChannelCounter(Channel channel) {
AtomicLong counter = channelCounters.get(channel);
if (counter == null) {
counter = new AtomicLong();
AtomicLong oldCounter = channelCounters.putIfAbsent(channel, counter);
if (oldCounter != null) {
counter = oldCounter;
}
}
// Remove the entry when the channel closes.
if (!channel.isOpen()) {
channelCounters.remove(channel);
}
return counter;
}
protected void decreaseCounter(Runnable task) {
if (!shouldCount(task)) {
return;
}
Settings settings = this.settings;
long maxChannelMemorySize = settings.maxChannelMemorySize;
int increment;
if (task instanceof ChannelEventRunnable) {
increment = ((ChannelEventRunnable) task).estimatedSize;
} else {
increment = ((MemoryAwareRunnable) task).estimatedSize;
}
if (totalLimiter != null) {
totalLimiter.decrease(increment);
}
if (task instanceof ChannelEventRunnable) {
ChannelEventRunnable eventTask = (ChannelEventRunnable) task;
Channel channel = eventTask.getEvent().getChannel();
long channelCounter = getChannelCounter(channel).addAndGet(-increment);
// System.out.println("DC: " + channelCounter + ", " + increment);
if (maxChannelMemorySize != 0 && channelCounter < maxChannelMemorySize && channel.isOpen()) {
if (!channel.isReadable()) {
// System.out.println("READABLE");
ChannelHandlerContext ctx = eventTask.getContext();
if (ctx.getHandler() instanceof ExecutionHandler) {
// check if the attachment was set as this means that we suspend the channel from reads.
// This only works when
// this pool is used with ExecutionHandler but I guess thats good enough for us.
//
// See #215
if (ctx.getAttachment() != null) {
// readSuspended = false;
ctx.setAttachment(null);
channel.setReadable(true);
}
} else {
channel.setReadable(true);
}
}
}
}
}
private boolean checkWritable(ChannelFuture future) {
boolean isWriteable = false;
Channel channel = future.channel();
if (future != null && channel.isOpen()) {
if (channel.isActive() && channel.isWritable()) {
isWriteable = true;
} else {
int count = m_attempts.incrementAndGet();
if (count % 1000 == 0 || count == 1) {
m_logger.error("Netty write buffer is full! Attempts: " + count);
}
}
}
return isWriteable;
}
public static void main(String[] args) throws Exception {
EventLoopGroup group = new NioEventLoopGroup();
try {
Bootstrap b = new Bootstrap();
b.group(group).channel(NioSocketChannel.class).handler(new TelnetClientInitializer());
Channel ch = b.connect(HOST, PORT).sync().channel();
while (true) {
Scanner scanner = new Scanner(System.in);
Double bet = null;
while (true) {
try {
bet = scanner.nextDouble();
if (bet > MIN_BET && bet < MAX_BET) {
break;
}
throw new InputMismatchException();
} catch (InputMismatchException e) {
System.out.println("Not correct!\r\n");
scanner.nextLine();
}
if (!ch.isOpen()) {
System.exit(0);
}
}
ch.writeAndFlush(bet + "\r\n");
while (true) {
String action = scanner.nextLine();
if (action.toLowerCase().equals(STAND) || action.toLowerCase().equals(DOUBLE)) {
ch.writeAndFlush(action);
break;
} else if (action.toLowerCase().equals(HIT)) {
ch.writeAndFlush(action);
}
}
}
} finally {
group.shutdownGracefully();
}
}
public void sendMsg(Channel channel) {
if (!channel.isOpen()) return;
for (int i = 0; i < size(); i++) {
int msgId = idBufList.get(bufCurIndex);
Chunk msgbuf = chunkBufList.get(bufCurIndex);
removeMsg();
// 构造头文件数据
ByteBuf head = channel.alloc().buffer(8);
head.writeInt(msgbuf.length + 8);
head.writeInt(msgId);
// 写入头数据
channel.write(head);
// Chunk类型的msgbuf肯定是protobuf直接生成的 所以buffer属性中不会有多余数据 才能这么用
// 其余地方Chunk类不建议直接使用内部的buffer
channel.write(msgbuf.buffer);
}
channel.flush();
}
public boolean isActive() {
return !timedOut && (channel.isOpen() || channel.isActive());
}
@Override
public void shutdown() {
if (channel.isOpen()) {
channel.close();
}
}
public void a(IChatBaseComponent var1) {
if (k.isOpen()) {
k.close().awaitUninterruptibly();
n = var1;
}
}
@Override
public void close() {
try {
if (mDone) {
return;
}
if (!mChannel.isOpen()) {
return;
}
try {
if (!CANCEL_ENABLED) {
mChannel.close().sync();
return;
}
if (remaining() > 0) {
Protocol.ReadRequest cancelRequest =
Protocol.ReadRequest.newBuilder()
.setId(mId)
.setCancel(true)
.setType(mRequestType)
.build();
mChannel
.writeAndFlush(new RPCProtoMessage(cancelRequest))
.addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
}
} catch (InterruptedException e) {
mChannel.close();
throw Throwables.propagate(e);
}
while (true) {
try {
ByteBuf buf = readPacket();
// A null packet indicates the end of the stream.
if (buf == null) {
return;
}
buf.release();
} catch (IOException e) {
LOG.warn(
"Failed to close the NettyBlockReader (block: {}, address: {}).", mId, mAddress, e);
try {
mChannel.close().sync();
} catch (InterruptedException ee) {
throw Throwables.propagate(ee);
}
return;
}
}
} finally {
if (mChannel.isOpen()) {
Preconditions.checkState(mChannel.pipeline().last() instanceof PacketReadHandler);
mChannel.pipeline().removeLast();
// Make sure "autoread" is on before realsing the channel.
resume();
}
mContext.releaseNettyChannel(mAddress, mChannel);
mClosed = true;
}
}
public boolean g() {
return (k != null) && k.isOpen();
}
