@Override
public void parseCommand(String[] message, ChannelHandlerContext ctx) {
String password = message[0];
if (password.equals("cometServer")) {
String command = message[1];
switch (command) {
default:
{
ctx.channel().writeAndFlush("response||You're connected!");
break;
}
case "stats":
{
ctx.channel()
.writeAndFlush("response||" + JsonFactory.getInstance().toJson(CometStats.get()));
break;
}
}
} else {
ctx.disconnect();
}
}
@Override
public void exceptionCaught(ChannelHandlerContext context, Throwable cause) {
LOG.error(cause.getMessage(), cause);
if (context.channel().isOpen()) {
context.channel().close();
}
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
RequestWrapper request = (RequestWrapper) msg;
long beginTime = System.currentTimeMillis();
ResponseWrapper responseWrapper =
ProtocolFactory.getServerHandler(request.getProtocolType()).handleRequest(request);
final int id = request.getId();
// already timeout,so not return
if ((System.currentTimeMillis() - beginTime) >= request.getTimeout()) {
LOGGER.warn(
"timeout,so give up send response to client,requestId is:"
+ id
+ ",client is:"
+ ctx.channel().remoteAddress()
+ ",consumetime is:"
+ (System.currentTimeMillis() - beginTime)
+ ",timeout is:"
+ request.getTimeout());
return;
}
ChannelFuture wf = ctx.channel().writeAndFlush(responseWrapper);
wf.addListener(
new ChannelFutureListener() {
public void operationComplete(ChannelFuture future) throws Exception {
if (!future.isSuccess()) {
LOGGER.error("server write response error,request id is: " + id);
}
}
});
}
// if we add any attributes, we should force removal of them here so that
// they do not hold references to the world and causes it to leak.
private void cleanAttributes(ChannelHandlerContext ctx) {
ctx.channel().attr(FMLOutboundHandler.FML_MESSAGETARGETARGS).remove();
ctx.channel().attr(NetworkRegistry.NET_HANDLER).remove();
ctx.channel().attr(NetworkDispatcher.FML_DISPATCHER).remove();
this.handshakeChannel.attr(FML_DISPATCHER).remove();
this.manager.channel().attr(FML_DISPATCHER).remove();
}
/**
* Called on exceptions in the client handler pipeline.
*
* <p>Remote exceptions are received as regular payload.
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
if (cause instanceof TransportException) {
notifyAllChannelsOfErrorAndClose(cause);
} else {
final SocketAddress remoteAddr = ctx.channel().remoteAddress();
final TransportException tex;
// Improve on the connection reset by peer error message
if (cause instanceof IOException && cause.getMessage().equals("Connection reset by peer")) {
tex =
new RemoteTransportException(
"Lost connection to task manager '"
+ remoteAddr
+ "'. This indicates "
+ "that the remote task manager was lost.",
remoteAddr,
cause);
} else {
tex = new LocalTransportException(cause.getMessage(), ctx.channel().localAddress(), cause);
}
notifyAllChannelsOfErrorAndClose(tex);
}
}
private void handleHTTP(OutPacketMessage msg, ChannelHandlerContext ctx, ChannelPromise promise)
throws IOException {
Channel channel = ctx.channel();
Attribute<Boolean> attr = channel.attr(WRITE_ONCE);
Queue<Packet> queue = msg.getClientHead().getPacketsQueue(msg.getTransport());
if (!channel.isActive() || queue.isEmpty() || !attr.compareAndSet(null, true)) {
promise.setSuccess();
return;
}
ByteBuf out = encoder.allocateBuffer(ctx.alloc());
Boolean b64 = ctx.channel().attr(EncoderHandler.B64).get();
if (b64 != null && b64) {
Integer jsonpIndex = ctx.channel().attr(EncoderHandler.JSONP_INDEX).get();
encoder.encodeJsonP(jsonpIndex, queue, out, ctx.alloc(), 50);
String type = "application/javascript";
if (jsonpIndex == null) {
type = "text/plain";
}
sendMessage(msg, channel, out, type, promise);
} else {
encoder.encodePackets(queue, out, ctx.alloc(), 50);
sendMessage(msg, channel, out, "application/octet-stream", promise);
}
}
private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) {
if (logger.isLoggable(Level.FINE)) {
logger.fine(
String.format(
"Channel %s received %s",
ctx.channel().hashCode(), frame.getClass().getSimpleName()));
}
if (frame instanceof CloseWebSocketFrame) {
handshaker.close(ctx.channel(), (CloseWebSocketFrame) frame);
} else if (frame instanceof PingWebSocketFrame) {
ctx.write(new PongWebSocketFrame(frame.isFinalFragment(), frame.rsv(), frame.content()));
} else if (frame instanceof TextWebSocketFrame) {
ctx.write(frame);
} else if (frame instanceof BinaryWebSocketFrame) {
ctx.write(frame);
} else if (frame instanceof ContinuationWebSocketFrame) {
ctx.write(frame);
} else if (frame instanceof PongWebSocketFrame) {
frame.release();
// Ignore
} else {
throw new UnsupportedOperationException(
String.format("%s frame types not supported", frame.getClass().getName()));
}
}
/**
* 取代netty3.0中的channelDisconnected(),客户端主动关闭连接
*
* @param ctx
* @throws Exception
*/
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
logger.info("[" + ctx.channel().remoteAddress() + "] : is inactive......");
handlerDispatcher.removeChannelInfo(ctx.channel());
System.out.println("[" + ctx.channel().remoteAddress() + "] : is inactive......");
ctx.close();
}
private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req) throws Exception {
// Handle a bad request.
if (!req.getDecoderResult().isSuccess()) {
sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, BAD_REQUEST));
req.release();
return;
}
// Allow only GET methods.
if (req.getMethod() != GET) {
sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, FORBIDDEN));
req.release();
return;
}
// Handshake
WebSocketServerHandshakerFactory wsFactory =
new WebSocketServerHandshakerFactory(
getWebSocketLocation(req), null, false, Integer.MAX_VALUE);
handshaker = wsFactory.newHandshaker(req);
if (handshaker == null) {
WebSocketServerHandshakerFactory.sendUnsupportedWebSocketVersionResponse(ctx.channel());
} else {
handshaker.handshake(ctx.channel(), req);
}
req.release();
}
/**
* Calls {@link ChannelHandlerContext#fireChannelRead(Object)} to forward to the next {@link
* ChannelHandler} in the {@link ChannelPipeline}.
*
* <p>Sub-classes may override this method to change behavior.
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
NettyMessage message = (NettyMessage) msg;
// 如果是握手请求消息，处理，其它消息透传
if (message.getHeader() != null
&& message.getHeader().getType() == MessageType.LOGIN_REQ.value()) {
String nodeIndex = ctx.channel().remoteAddress().toString();
NettyMessage loginResp = null;
// 重复登陆，拒绝
if (nodeCheck.containsKey(nodeIndex)) {
loginResp = buildResponse((byte) -1);
} else {
InetSocketAddress address = (InetSocketAddress) ctx.channel().remoteAddress();
String ip = address.getAddress().getHostAddress();
boolean isOK = false;
for (String WIP : whitekList) {
if (WIP.equals(ip)) {
isOK = true;
break;
}
}
loginResp = isOK ? buildResponse((byte) 0) : buildResponse((byte) -1);
if (isOK) nodeCheck.put(nodeIndex, true);
}
System.out.println(
"The login response is : " + loginResp + " body [" + loginResp.getBody() + "]");
ctx.writeAndFlush(loginResp);
} else {
ctx.fireChannelRead(msg);
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
logger.error("[" + ctx.channel().remoteAddress() + "] 出异常……");
// cause.printStackTrace();
handlerDispatcher.removeChannelInfo(ctx.channel());
ctx.close();
}
private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) {
System.out.println("pre1:" + frame);
// Check for closing frame
if (frame instanceof CloseWebSocketFrame) {
handshaker.close(ctx.channel(), (CloseWebSocketFrame) frame.retain());
return;
}
if (frame instanceof PingWebSocketFrame) {
ctx.channel().write(new PongWebSocketFrame(frame.content().retain()));
return;
}
if (!(frame instanceof TextWebSocketFrame)) {
throw new UnsupportedOperationException(
String.format("%s frame types not supported", frame.getClass().getName()));
}
WebsocketMessageHandlerI websocketMessageHandler = new WebSocketMessageHander(ctx, channels);
// Send the uppercase string back.
String requestRaw = ((TextWebSocketFrame) frame).text();
websocketMessageHandler.handleMessage(requestRaw);
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
FullHttpRequest req = (FullHttpRequest) msg;
String upgrade = req.headers().get(HttpHeaders.Names.UPGRADE);
if (HttpHeaders.Values.WEBSOCKET.equalsIgnoreCase(upgrade)) {
WebSocketServerHandshakerFactory wsFactory =
new WebSocketServerHandshakerFactory(req.getUri(), null, false);
WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req);
if (handshaker == null) {
WebSocketServerHandshakerFactory.sendUnsupportedWebSocketVersionResponse(ctx.channel());
} else {
ChannelFuture future = handshaker.handshake(ctx.channel(), req);
future.addListener(
f -> {
this.configurator.switchToWebSockets(ctx.pipeline());
});
}
} else {
ReferenceCountUtil.retain(msg);
this.configurator.switchToPlainHttp(ctx.pipeline());
ChannelHandlerContext agg = ctx.pipeline().context(HttpObjectAggregator.class);
agg.fireChannelRead(msg);
}
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, DatagramPacket packet) throws Exception {
String request = packet.content().toString(CharsetUtil.UTF_8);
if (logger.isDebugEnabled())
logger.debug("Sender " + packet.sender() + " sent request:" + request);
if (!sessionList.inverse().containsKey(packet.sender())) {
String session = UUID.randomUUID().toString();
String localAddress = ctx.channel().localAddress().toString();
String remoteAddress = ctx.channel().remoteAddress().toString();
SubscriptionManagerFactory.getInstance()
.add(session, session, outputType, localAddress, remoteAddress);
sessionList.put(session, packet.sender());
if (logger.isDebugEnabled())
logger.debug("Added Sender " + packet.sender() + ", session:" + session);
ctx.channel()
.writeAndFlush(
new DatagramPacket(
Unpooled.copiedBuffer(
Util.getWelcomeMsg().toString() + "\r\n", CharsetUtil.UTF_8),
packet.sender()));
}
Map<String, Object> headers = getHeaders(sessionList.inverse().get(packet.sender()));
producer.sendBodyAndHeaders(request, headers);
}
@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);
}
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
LOGGER.debug(
String.format("[%s]\n========关闭连接=======", ctx.channel().localAddress().toString()));
LOGGER.debug(ctx.channel().remoteAddress().toString());
LOGGER.debug(ctx.channel().attr(AttributeKey.valueOf("haha")).get().toString());
}
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof List) {
@SuppressWarnings("unchecked")
List<ResponseWrapper> responses = (List<ResponseWrapper>) msg;
if (isDebugEnabled) {
// for performance trace
LOGGER.debug(
"receive response list from server: "
+ ctx.channel().remoteAddress()
+ ",list size is:"
+ responses.size());
}
client.putResponses(responses);
} else if (msg instanceof ResponseWrapper) {
ResponseWrapper response = (ResponseWrapper) msg;
if (isDebugEnabled) {
// for performance trace
LOGGER.debug(
"receive response list from server: "
+ ctx.channel().remoteAddress()
+ ",request is:"
+ response.getRequestId());
}
client.putResponse(response);
} else {
LOGGER.error("receive message error,only support List || ResponseWrapper");
throw new Exception("receive message error,only support List || ResponseWrapper");
}
}
/**
* 取代netty3.0中的channelConnected()
*
* @param ctx
* @throws Exception
*/
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
// super.channelActive(ctx);
handlerDispatcher.addChannel(ctx.channel());
handlerDispatcher.getMessageQueueHandler().addMessageQueue(ctx.channel()); // 存入对应客户端获取的消息队列
logger.info("[" + ctx.channel().remoteAddress() + "] : is active......");
System.out.println("[" + ctx.channel().remoteAddress() + "] : is active......");
}
// 暴力停止某个终端，其他终端都会收到离开的信息
@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception { // (3)
Channel incoming = ctx.channel();
for (Channel channel : channels) {
channel.writeAndFlush("[SERVER] - " + incoming.remoteAddress() + " 离开\n");
}
channels.remove(ctx.channel());
}
/**
* Completes the request by closing the request and network channel (if {@code
* closeNetworkChannel} is {@code true}). May also close the channel if the class internally is
* forcing a close (i.e. if {@link #close()} is called.
*
* @param closeNetworkChannel network channel is closed if {@code true}.
*/
private void completeRequest(boolean closeNetworkChannel) {
if ((closeNetworkChannel || forceClose) && ctx.channel().isOpen()) {
writeFuture.addListener(ChannelFutureListener.CLOSE);
logger.trace("Requested closing of channel {}", ctx.channel());
}
closeRequest();
responseComplete = true;
}
@Override
public void messageReceived(ChannelHandlerContext context, LoginRequest message)
throws Exception {
if (context.channel().isOpen()) {
Castlewood.getServiceManager()
.getService(LoginService.class)
.push(new ChannelRequest<>(context.channel(), message));
}
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
RedisConnection connection = RedisConnection.getFrom(ctx.channel());
if (!connection.isClosed()) {
EventLoopGroup group = ctx.channel().eventLoop().parent();
reconnect(group, connection);
}
ctx.fireChannelInactive();
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
final Channel inboundChannel = ctx.channel();
// Start the connection attempt.
Bootstrap bootstrap = new Bootstrap();
bootstrap
.group(inboundChannel.eventLoop())
.channel(ctx.channel().getClass())
.handler(
new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
// Create a default pipeline implementation.
ChannelPipeline pipeline = ch.pipeline();
// add logging
if (logger.isDebugEnabled()) {
pipeline.addLast("logger", new LoggingHandler(" -->"));
}
// add HTTPS proxy -> server support
if (secure) {
SSLEngine engine = SSLFactory.sslContext().createSSLEngine();
engine.setUseClientMode(true);
pipeline.addLast("proxy -> server ssl", new SslHandler(engine));
}
// add handler
pipeline.addLast(
new ProxyRelayHandler(
inboundChannel,
bufferedCapacity,
new RequestInterceptor(),
" -->"));
}
})
.option(ChannelOption.AUTO_READ, false);
ChannelFuture channelFuture = bootstrap.connect(remoteSocketAddress);
outboundChannel = channelFuture.channel();
channelFuture.addListener(
new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
if (future.isSuccess()) {
channelBuffer.clear();
bufferedMode = bufferedCapacity > 0;
flushedBuffer = false;
// connection complete start to read first data
inboundChannel.read();
} else {
// Close the connection if the connection attempt has failed.
inboundChannel.close();
}
}
});
}
@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception { // (3)
Channel incoming = ctx.channel();
for (Channel channel : sChannels) {
channel.writeAndFlush(
new TextWebSocketFrame("[SERVER] - " + incoming.remoteAddress() + " 离开"));
}
System.out.println("Client:" + incoming.remoteAddress() + "离开");
sChannels.remove(ctx.channel());
}
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
if (evt == WebSocketServerProtocolHandler.ServerHandshakeStateEvent.HANDSHAKE_COMPLETE) {
ctx.pipeline().remove(HttpRequestHandler.class);
group.writeAndFlush(new TextWebSocketFrame("Client " + ctx.channel() + " joined!"));
group.add(ctx.channel());
} else {
super.userEventTriggered(ctx, evt);
}
}
@Override
public void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
ChannelFuture f = null;
if (null != policyFile) {
f = ctx.channel().writeAndFlush(policyFile);
} else {
f = ctx.channel().writeAndFlush(this.getPolicyFileContents());
}
f.addListener(ChannelFutureListener.CLOSE);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
if (cause instanceof IOException) {
ctx.channel().close();
return;
}
logger.error(cause.getMessage(), cause.getCause());
if (ctx.channel().isOpen()) {
ctx.channel().close();
}
}
/**
* Push a cache entry value out onto the websocket channel (to the browser).
*
* @param key The cache entry key whose value is to be pushed to the browser.
* @param cache The cache containing the key.
* @param ctx The channel context associated with the browser websocket channel..
*/
public static void pushCacheValue(
String key, Cache<Object, Object> cache, ChannelHandlerContext ctx) {
Object value = cache.get(key);
JsonObject responseObject = toJSON(key, value, cache.getName());
// Write the JSON response out onto the channel...
ctx.channel()
.writeAndFlush(
new TextWebSocketFrame(responseObject.toString()), ctx.channel().voidPromise());
}
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
MDC.put("channel", String.format("[id: 0x%08x]", ctx.channel().hashCode()));
if (evt instanceof IdleStateEvent) {
LOGGER.error(
"Idle connection ({}). PDUs received: {}",
ctx.channel().remoteAddress(),
this.amountOfResponsesReceived);
}
super.userEventTriggered(ctx, evt);
}
private void write(XHROptionsMessage msg, ChannelHandlerContext ctx, ChannelPromise promise) {
HttpResponse res = new DefaultHttpResponse(HTTP_1_1, HttpResponseStatus.OK);
HttpHeaders.addHeader(res, "Set-Cookie", "io=" + msg.getSessionId());
HttpHeaders.addHeader(res, CONNECTION, KEEP_ALIVE);
HttpHeaders.addHeader(res, ACCESS_CONTROL_ALLOW_HEADERS, CONTENT_TYPE);
addOriginHeaders(ctx.channel(), res);
ByteBuf out = encoder.allocateBuffer(ctx.alloc());
sendMessage(msg, ctx.channel(), out, res, promise);
}