@Override
public void channelOpen(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
// Suspend incoming traffic until connected to the remote host.
final Channel inboundChannel = e.getChannel();
inboundChannel.setReadable(false);
// Start the connection attempt.
ClientBootstrap cb = new ClientBootstrap(cf);
cb.getPipeline().addLast("handler", new OutboundHandler(e.getChannel()));
ChannelFuture f = cb.connect(new InetSocketAddress(remoteHost, remotePort));
outboundChannel = f.getChannel();
f.addListener(
new ChannelFutureListener() {
public void operationComplete(ChannelFuture future) throws Exception {
if (future.isSuccess()) {
// Connection attempt succeeded:
// Begin to accept incoming traffic.
inboundChannel.setReadable(true);
} else {
// Close the connection if the connection attempt has failed.
inboundChannel.close();
}
}
});
}
/**
* Detects if we're connecting to a Found Elasticsearch cluster (using pre-configured host
* suffixes) and adds a SSL handler at the beginning of the pipeline if we're connecting to a
* SSL-endpoint (using a list of pre-configured ports).
*/
@Override
public void connectRequested(final ChannelHandlerContext ctx, final ChannelStateEvent e)
throws Exception {
if (e.getValue() instanceof InetSocketAddress) {
InetSocketAddress inetSocketAddress = (InetSocketAddress) e.getValue();
for (String suffix : hostSuffixes) {
isFoundCluster = isFoundCluster || inetSocketAddress.getHostString().endsWith(suffix);
}
if (isFoundCluster) {
for (int sslPort : sslPorts) {
if (inetSocketAddress.getPort() == sslPort) {
logger.debug(
"Enabling SSL on transport layer with unsafeAllowSelfSigned=[{}].",
unsafeAllowSelfSigned);
FoundSSLHandler handler =
FoundSSLUtils.getSSLHandler(unsafeAllowSelfSigned, inetSocketAddress);
ctx.getPipeline().addFirst("ssl", handler);
break;
}
}
} else {
ctx.getPipeline().remove(this);
}
}
super.connectRequested(ctx, e);
}
public void operationComplete(ChannelFuture closeNotifyFuture) throws Exception {
if (!(closeNotifyFuture.getCause() instanceof ClosedChannelException)) {
Channels.close(context, e.getFuture());
} else {
e.getFuture().setSuccess();
}
}
@Override
public void channelOpen(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
AbstractNettyServer.ALL_CHANNELS.add(e.getChannel());
LOG.debug(
"Added Channel with id: {} as the {}th open channel",
e.getChannel().getId(),
CHANNEL_COUNTER.incrementAndGet());
}
/**
* Attention please,
*
* @see
* org.jboss.netty.channel.SimpleChannelUpstreamHandler#channelDisconnected(org.jboss.netty.channel.ChannelHandlerContext,
* org.jboss.netty.channel.ChannelStateEvent)
*/
@Override
public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
LOG.info(
"Receive channelDisconnected to {}, channel = {}", client.getRemoteAddr(), e.getChannel());
// ctx.sendUpstream(e);
super.channelDisconnected(ctx, e);
client.disconnectChannel(e.getChannel());
}
public void handleDownstream(final ChannelHandlerContext context, final ChannelEvent evt)
throws Exception {
if (evt instanceof ChannelStateEvent) {
ChannelStateEvent e = (ChannelStateEvent) evt;
switch (e.getState()) {
case OPEN:
case CONNECTED:
case BOUND:
if (Boolean.FALSE.equals(e.getValue()) || e.getValue() == null) {
closeOutboundAndChannel(context, e);
return;
}
}
}
if (!(evt instanceof MessageEvent)) {
context.sendDownstream(evt);
return;
}
MessageEvent e = (MessageEvent) evt;
if (!(e.getMessage() instanceof ChannelBuffer)) {
context.sendDownstream(evt);
return;
}
// Do not encrypt the first write request if this handler is
// created with startTLS flag turned on.
if (startTls && sentFirstMessage.compareAndSet(false, true)) {
context.sendDownstream(evt);
return;
}
// Otherwise, all messages are encrypted.
ChannelBuffer msg = (ChannelBuffer) e.getMessage();
PendingWrite pendingWrite;
if (msg.readable()) {
pendingWrite =
new PendingWrite(
evt.getFuture(), msg.toByteBuffer(msg.readerIndex(), msg.readableBytes()));
} else {
pendingWrite = new PendingWrite(evt.getFuture(), null);
}
synchronized (pendingUnencryptedWrites) {
boolean offered = pendingUnencryptedWrites.offer(pendingWrite);
assert offered;
}
wrap(context, evt.getChannel());
}
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) {
final NioSocketChannel ch = (NioSocketChannel) e.getChannel();
NioWorker worker = ch.getWorker();
// Choose a handler
final HandlerHolder handler = handlerManager.chooseHandler(worker);
if (handler == null) {
// Ignore
return;
}
VertxInternal.instance.executeOnContext(
handler.contextID,
new Runnable() {
public void run() {
VertxInternal.instance.setContextID(handler.contextID);
NetSocket sock = new NetSocket(ch, handler.contextID, Thread.currentThread());
socketMap.put(ch, sock);
handler.handler.handle(sock);
}
});
}
@Override
public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
Channel channel = e.getChannel();
logger.info("channel disconnected at :{}", channel);
streamClientListener.onDisconnected(channel);
super.channelDisconnected(ctx, e);
}
@Override
public void channelInterestChanged(ChannelHandlerContext ctx, ChannelStateEvent e)
throws Exception {
final NioSocketChannel ch = (NioSocketChannel) e.getChannel();
final DefaultNetSocket sock = socketMap.get(ch);
ChannelState state = e.getState();
if (state == ChannelState.INTEREST_OPS) {
sock.getContext()
.execute(
new Runnable() {
public void run() {
sock.handleInterestedOpsChanged();
}
});
}
}
@Override
public void channelDisconnected(final ChannelHandlerContext ctx, final ChannelStateEvent e)
throws Exception {
chan = null;
super.channelDisconnected(ctx, e); // Let the ReplayingDecoder cleanup.
cleanup(e.getChannel());
}
@Override
public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
// Make sure the handshake future is notified when a connection has
// been closed during handshake.
synchronized (handshakeLock) {
if (handshaking) {
handshakeFuture.setFailure(new ClosedChannelException());
}
}
try {
super.channelDisconnected(ctx, e);
} finally {
unwrap(ctx, e.getChannel(), ChannelBuffers.EMPTY_BUFFER, 0, 0);
engine.closeOutbound();
if (!sentCloseNotify.get() && handshaken) {
try {
engine.closeInbound();
} catch (SSLException ex) {
logger.debug("Failed to clean up SSLEngine.", ex);
}
}
}
}
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
String welcome =
"Welcome to Onion Router!\nYou're node name is "
+ GlobalVars.nodeName()
+ "\nType each command with a trailing semicolon\nType 'help;' to see the commands\n\n>";
TerminalWrite.write(e.getChannel(), welcome);
}
/** 向server端发送消息 */
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent event) {
System.out.println("client start..");
String message = "[" + name + "]baicai AAA";
ChannelBuffer channelBuffer = ChannelBuffers.wrappedBuffer(message.getBytes());
event.getChannel().write(channelBuffer);
}
@Override
public void channelClosed(final ChannelHandlerContext ctx, final ChannelStateEvent e) {
chan = null;
// No need to call super.channelClosed() because we already called
// super.channelDisconnected(). If we get here without getting a
// DISCONNECTED event, then we were never connected in the first place so
// the ReplayingDecoder has nothing to cleanup.
cleanup(e.getChannel());
}
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
lock.acquire();
try {
channelSetter.setChannel(e.getChannel());
} finally {
lock.release();
}
}
@Override
public void channelOpen(ChannelHandlerContext ctx, ChannelStateEvent channelStateEvent)
throws Exception {
if (LOG.isTraceEnabled()) {
LOG.trace("Channel open: {}", ctx.getChannel());
}
// to keep track of open sockets
producer.getAllChannels().add(channelStateEvent.getChannel());
}
@Override
public void channelConnected(final ChannelHandlerContext ctx, final ChannelStateEvent e) {
final Channel chan = e.getChannel();
ChannelBuffer header = connectionHeaderPreamble();
header.writerIndex(RPC_HEADER.length);
Channels.write(chan, header);
secureRpcHelper = new SecureRpcHelper(this);
secureRpcHelper.sendHello(chan);
}
private void closeOutboundAndChannel(
final ChannelHandlerContext context, final ChannelStateEvent e) throws SSLException {
if (!e.getChannel().isConnected()) {
context.sendDownstream(e);
return;
}
unwrap(context, e.getChannel(), ChannelBuffers.EMPTY_BUFFER, 0, 0);
if (!engine.isInboundDone()) {
if (sentCloseNotify.compareAndSet(false, true)) {
engine.closeOutbound();
ChannelFuture closeNotifyFuture = wrapNonAppData(context, e.getChannel());
closeNotifyFuture.addListener(new ClosingChannelFutureListener(context, e));
return;
}
}
context.sendDownstream(e);
}
@Override
public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
super.channelClosed(ctx, e);
if (!ctx.getChannel().isOpen()) {
tryToFinishOffChannel(ctx.getChannel());
}
channelGroup.remove(e.getChannel());
}
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
Channel channel = e.getChannel();
System.out.println(channel.getRemoteAddress().toString());
System.out.println("channelConnected...");
String msg = "welcome rookiefly...";
ChannelBuffer buffer = ChannelBuffers.buffer(1024);
buffer.writeBytes(msg.getBytes());
channel.write(buffer);
ctx.sendUpstream(e);
}
private void sendNumbers(ChannelStateEvent e) {
Channel channel = e.getChannel();
while (channel.isWritable()) {
if (i <= count) {
channel.write(Integer.valueOf(i));
i++;
} else {
break;
}
}
}
/** Sometime when connect one bad channel which isn't writable, it will call this function */
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent event) {
// register the newly established channel
Channel channel = event.getChannel();
LOG.info(
"connection established to :{}, local port:{}",
client.getRemoteAddr(),
channel.getLocalAddress());
client.handleResponse();
}
@Override
public void channelInterestChanged(ChannelHandlerContext ctx, ChannelStateEvent e)
throws Exception {
// If inboundChannel is not saturated anymore, continue accepting
// the incoming traffic from the outboundChannel.
synchronized (trafficLock) {
if (e.getChannel().isWritable()) {
outboundChannel.setReadable(true);
}
}
}
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
// Событие вызывается при подключении клиента. Я создаю здесь Worker игрока — объект, который
// занимается обработкой данных игрока
// непостредственно.
// Я передаю ему канал игрока (функция e.getChannel()), чтобы он мог в него посылать пакеты
worker = workerClass.newInstance();
worker.setChannel(e.getChannel());
worker.setClientHandler(this);
// worker = new InterserverWorker(this, e.getChannel());
// log.info("channelConnected");
}
@Override
public void channelInterestChanged(ChannelHandlerContext ctx, ChannelStateEvent e)
throws Exception {
final NioSocketChannel ch = (NioSocketChannel) e.getChannel();
final ClientConnection conn = connectionMap.get(ch);
runOnCorrectThread(
ch,
new Runnable() {
public void run() {
conn.handleInterestedOpsChanged();
}
});
}
@Override
@LogMessageDoc(
message = "New switch connection from {ip address}",
explanation = "A new switch has connected from the " + "specified IP address")
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
log.debug(
"channelConnected on OFChannelHandler {}",
String.format("%08x", System.identityHashCode(this)));
counters.switchConnected.increment();
channel = e.getChannel();
log.info("New switch connection from {}", channel.getRemoteAddress());
setState(new WaitHelloState());
}
/**
* Handle downstream event.
*
* @param pipeline the {@link ChannelPipeline} that passes down the downstream event.
* @param e The downstream event.
*/
@Override
public void eventSunk(final ChannelPipeline pipeline, final ChannelEvent e) throws Exception {
final NioDatagramChannel channel = (NioDatagramChannel) e.getChannel();
final ChannelFuture future = e.getFuture();
if (e instanceof ChannelStateEvent) {
final ChannelStateEvent stateEvent = (ChannelStateEvent) e;
final ChannelState state = stateEvent.getState();
final Object value = stateEvent.getValue();
switch (state) {
case OPEN:
if (Boolean.FALSE.equals(value)) {
channel.worker.close(channel, future);
}
break;
case BOUND:
if (value != null) {
bind(channel, future, (InetSocketAddress) value);
} else {
channel.worker.close(channel, future);
}
break;
case CONNECTED:
if (value != null) {
connect(channel, future, (InetSocketAddress) value);
} else {
NioDatagramWorker.disconnect(channel, future);
}
break;
case INTEREST_OPS:
channel.worker.setInterestOps(channel, future, ((Integer) value).intValue());
break;
}
} else if (e instanceof MessageEvent) {
final MessageEvent event = (MessageEvent) e;
final boolean offered = channel.writeBufferQueue.offer(event);
assert offered;
channel.worker.writeFromUserCode(channel);
}
}
@Override
public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) {
final NioSocketChannel ch = (NioSocketChannel) e.getChannel();
final ClientConnection conn = connectionMap.remove(ch);
if (conn != null) {
runOnCorrectThread(
ch,
new Runnable() {
public void run() {
conn.handleClosed();
}
});
}
}
@Override
public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) {
final NioSocketChannel ch = (NioSocketChannel) e.getChannel();
final NetSocket sock = socketMap.remove(ch);
if (sock != null) {
VertxInternal.instance.executeOnContext(
sock.getContextID(),
new Runnable() {
public void run() {
sock.handleClosed();
}
});
}
}
@Override
public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) {
final NioSocketChannel ch = (NioSocketChannel) e.getChannel();
final DefaultNetSocket sock = socketMap.remove(ch);
if (sock != null) {
sock.getContext()
.execute(
new Runnable() {
public void run() {
sock.handleClosed();
}
});
}
}