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 channelRead(final ChannelHandlerContext ctx, final Object msg) throws Exception { if (msg instanceof ByteBuf) { // handle normal request final ByteBuf chunk = (ByteBuf) msg; if (flushedBuffer) { bufferedMode = false; } if (bufferedMode) { try { channelBuffer.writeBytes(chunk); ctx.channel().read(); } catch (IndexOutOfBoundsException iobe) { logger.trace( "Flushing buffer upstream and switching to chunked mode as downstream response too large"); bufferedMode = false; // write and flush buffer upstream if (outboundChannel.isActive()) { outboundChannel .writeAndFlush(channelBuffer) .addListener( new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { if (future.isSuccess()) { // write and flush this chunk upstream in case this single chunk is too // large for buffer channelRead(ctx, chunk); } else { future.channel().close(); } } }); } } } else { bufferedMode = false; if (outboundChannel.isActive()) { outboundChannel .writeAndFlush(chunk) .addListener( new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { if (future.isSuccess()) { // was able to flush out data, start to read the next chunk ctx.channel().read(); } else { future.channel().close(); } } }); } } } }
public synchronized void pause() { if (paused) { return; } if (channelClazz == null) { return; } // We *pause* the acceptor so no new connections are made if (serverChannelGroup != null) { ChannelGroupFuture future = serverChannelGroup.close().awaitUninterruptibly(); if (!future.isSuccess()) { ActiveMQServerLogger.LOGGER.nettyChannelGroupBindError(); Iterator<Channel> iterator = future.group().iterator(); while (iterator.hasNext()) { Channel channel = iterator.next(); if (channel.isActive()) { ActiveMQServerLogger.LOGGER.nettyChannelStillBound(channel, channel.remoteAddress()); } } } } paused = true; }
@Override public void dispatch(Channel session, Request request) { if (request != null) { int sn = request.getSn(); int module = request.getModule(); int cmd = request.getCmd(); Response response = Response.valueOf(sn, module, cmd); response.setMessageType(request.getMessageType()); CommandResolver commandResolver = COMMAND_RESOLVER.get(Integer.valueOf(cmd)); if (commandResolver != null) { if (logger.isDebugEnabled()) { logger.debug( String.format( "module:[%d], cmd:[%d]", new Object[] {Integer.valueOf(module), Integer.valueOf(cmd)})); } try { commandResolver.execute(request); } catch (Exception e) { e.printStackTrace(); } } else { if (logger.isDebugEnabled()) { logger.error( String.format( "No Invoker for module:[%d], cmd:[%d]", new Object[] {Integer.valueOf(module), Integer.valueOf(cmd)})); } response.setStatus(-1); if (session.isActive()) { session.writeAndFlush(response); } } } }
public void onMessage(Message message) { if (message.getType() == MessageType.MSG && message.get(MessageProperty.ROOM).equals("#main")) { long userId = message.get(MessageProperty.USER_ID); String name = message.get(MessageProperty.NAME); UserCredentials userCredentials = null; if (needsFetchingConnectionData(userId)) { userCredentials = fetchConnectionDataForUser(name, userId); } if (userCredentials != null) { String id = userCredentials.getId(); Channel channel = connections.get(id.toLowerCase()); if (channel == null || !channel.isActive()) { try { channel = createConnection(id, userCredentials.getToken()); } catch (InterruptedException e) { logger.warn("", e); } } if (channel != null) { channel.attr(lastMessageAttrKey).set(System.currentTimeMillis()); channel.writeAndFlush( "PRIVMSG #" + this.channel + " :" + message.get(MessageProperty.TEXT) + "\r\n"); } } } }
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); } }
void responseReceived(int id, @Nullable ByteBuf buffer) { Channel channel = requests.remove(id); if (channel == null || !channel.isActive()) { if (buffer != null) { buffer.release(); } return; } if (buffer == null) { Responses.sendStatus(HttpResponseStatus.BAD_GATEWAY, channel); return; } HttpResponse httpResponse = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, buffer); try { parseHeaders(httpResponse, buffer); Responses.addServer(httpResponse); if (!HttpHeaderUtil.isContentLengthSet(httpResponse)) { HttpHeaderUtil.setContentLength(httpResponse, buffer.readableBytes()); } } catch (Throwable e) { buffer.release(); try { LOG.error(e); } finally { Responses.sendStatus(HttpResponseStatus.INTERNAL_SERVER_ERROR, channel); } return; } channel.writeAndFlush(httpResponse); }
/** Stop listening */ public void unbind() { final Channel _channel = channel; if (_channel != null && _channel.isActive()) { _channel.close(); channel = null; } }
@Override public void inboundBufferUpdated(ChannelHandlerContext ctx, ByteBuf in) throws Exception { ByteBuf out = outboundChannel.outboundByteBuffer(); out.writeBytes(in); if (outboundChannel.isActive()) { outboundChannel.flush(); } }
@Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { cause.printStackTrace(); Channel ch = ctx.channel(); if (ch.isActive()) { ch.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE); } }
private static void sendBadGateway(@NotNull Channel channel) { try { if (channel.isActive()) { Responses.sendStatus(HttpResponseStatus.BAD_GATEWAY, channel); } } catch (Throwable e) { NettyUtil.log(e, LOG); } }
static boolean isActive(Channel ch) { final boolean active; if (!ch.isActive()) { active = false; } else { final HttpSessionHandler sessionHandler = ch.pipeline().get(HttpSessionHandler.class); active = sessionHandler != null ? sessionHandler.active : false; } return active; }
@Test public void testExceptionChannelActive() throws Exception { sut.setState(CommandHandler.LifecycleState.ACTIVE); when(channel.isActive()).thenReturn(true); sut.channelActive(context); sut.exceptionCaught(context, new Exception()); verify(context).fireExceptionCaught(any(Exception.class)); }
/** Binds this server to the address specified in the configuration. */ private void bind() { SocketAddress address = getBindAddress(ServerConfig.Key.SERVER_PORT); logger.info("Binding to address: " + address + "..."); ChannelFuture future = networkServer.bind(address); Channel channel = future.awaitUninterruptibly().channel(); if (!channel.isActive()) { throw new RuntimeException("Failed to bind to address. Maybe it is already in use?"); } }
public static void main(String[] args) throws Exception { // Address to bind on / connect to. // final LocalAddress addr = new LocalAddress(PORT); final InetAddress HOST = InetAddress.getByName("192.168.220.128"); // final InetSocketAddress addr = InetSocketAddress.createUnresolved("192.168.220.128", // Integer.parseInt(PORT)); NioEventLoopGroup clientGroup = new NioEventLoopGroup(); // NIO event loops are also OK final SslContext sslCtx = null; try { Bootstrap b = new Bootstrap(); b.group(clientGroup) .channel(NioSocketChannel.class) .option(ChannelOption.TCP_NODELAY, true) .handler( new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline p = ch.pipeline(); // p.addLast(new LoggingHandler(LogLevel.INFO)); p.addLast(new LocalEchoClientHandler()); } }); // Start the client. ChannelFuture f = b.connect(HOST, PORT).sync(); ByteBuf subsequentMessage = null; byte[] bytes = null; Channel ch = b.connect(HOST, PORT).channel(); String line = null; System.out.println("Feel free to chat here"); while (true) { line = new BufferedReader(new InputStreamReader(System.in)).readLine(); if (line.equalsIgnoreCase("quit") || !ch.isActive()) { System.out.println("Prepare to close the connection."); break; } subsequentMessage = Unpooled.buffer(); bytes = line.getBytes(); subsequentMessage.writeBytes(bytes); ch.writeAndFlush(subsequentMessage); } // Wait until the connection is closed. f.channel().closeFuture().sync(); } finally { clientGroup.shutdownGracefully(); System.out.println("Client closed"); } }
@Override public Channel fetch() { Channel ch = channels.fetch(); if (ch != null && ch.isActive()) { if (ch.attr(GlobalConstance.attributeKey).get() == SessionState.Connect) { return ch; } } return null; }
/** * Writes an the {@link Events#DISCONNECT} to the client, flushes all the pending writes and * closes the channel. */ @Override public void close() { LOG.debug("Going to close tcp connection in class: {}", this.getClass().getName()); Event event = Events.event(null, Events.DISCONNECT); if (channel.isActive()) { channel.write(event).addListener(ChannelFutureListener.CLOSE); } else { channel.close(); LOG.trace("Unable to write the Event {} with type {} to socket", event, event.getType()); } }
public void channelRead(final ChannelHandlerContext remoteChannelCtx, final Object msg) throws Exception { LoggerUtil.debug( logger, uaChannel.attr(ApnProxyConnectionAttribute.ATTRIBUTE_KEY), "Remote msg", msg); remainMsgCount++; if (remainMsgCount <= 5) { remoteChannelCtx.read(); } HttpObject ho = (HttpObject) msg; if (ho instanceof HttpResponse) { HttpResponse httpResponse = (HttpResponse) ho; LoggerUtil.info( forwardRestLogger, uaChannel.attr(ApnProxyConnectionAttribute.ATTRIBUTE_KEY), httpResponse.getStatus(), httpResponse.getProtocolVersion()); httpResponse.headers().set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.KEEP_ALIVE); httpResponse.headers().set("Proxy-Connection", HttpHeaders.Values.KEEP_ALIVE); } if (uaChannel.isActive()) { uaChannel .writeAndFlush(ho) .addListener( new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { LoggerUtil.debug( logger, uaChannel.attr(ApnProxyConnectionAttribute.ATTRIBUTE_KEY), "Write to UA finished: " + future.isSuccess()); if (future.isSuccess()) { remainMsgCount--; remoteChannelCtx.read(); LoggerUtil.debug( logger, uaChannel.attr(ApnProxyConnectionAttribute.ATTRIBUTE_KEY), "Fire read again"); } else { remoteChannelCtx.close(); } } }); } else { remoteChannelCtx.close(); } }
/** Binds the query server to the address specified in the configuration. */ private void bindQuery() { if (!config.getBoolean(ServerConfig.Key.QUERY_ENABLED)) { return; } SocketAddress address = getBindAddress(ServerConfig.Key.QUERY_PORT); queryServer = new QueryServer(this, config.getBoolean(ServerConfig.Key.QUERY_PLUGINS)); logger.info("Binding query to address: " + address + "..."); ChannelFuture future = queryServer.bind(address); Channel channel = future.awaitUninterruptibly().channel(); if (!channel.isActive()) { logger.warning("Failed to bind query. Address already in use?"); } }
private void markAsDone(NettyResponseFuture<?> future, final Channel channel) throws MalformedURLException { // We need to make sure everything is OK before adding the // connection back to the pool. try { future.done(); } catch (Throwable t) { // Never propagate exception once we know we are done. LOGGER.debug(t.getMessage(), t); } if (!future.isKeepAlive() || !channel.isActive()) { channels.closeChannel(channel); } }
/** Binds the rcon server to the address specified in the configuration. */ private void bindRcon() { if (!config.getBoolean(ServerConfig.Key.RCON_ENABLED)) { return; } SocketAddress address = getBindAddress(ServerConfig.Key.RCON_PORT); rconServer = new RconServer(this, config.getString(ServerConfig.Key.RCON_PASSWORD)); logger.info("Binding rcon to address: " + address + "..."); ChannelFuture future = rconServer.bind(address); Channel channel = future.awaitUninterruptibly().channel(); if (!channel.isActive()) { logger.warning("Failed to bind rcon. Address already in use?"); } }
public void bind(int port) throws BindException { SocketAddress address = this.getBindAddress(port); this.getLogger().info("Binding to address: " + address); ChannelFuture future = this.network.bind(address); Channel channel = future.awaitUninterruptibly().channel(); if (!channel.isActive()) { Throwable cause = future.cause(); if ((cause instanceof BindException)) { throw ((BindException) cause); } throw new RuntimeException("Failed to bind to address", cause); } this.getLogger().info("Successfully bound to: " + channel.localAddress()); this.port = ((InetSocketAddress) channel.localAddress()).getPort(); }
@Test public void testExceptionWithQueue() throws Exception { sut.setState(CommandHandler.LifecycleState.ACTIVE); q.clear(); sut.channelActive(context); when(channel.isActive()).thenReturn(true); q.add(command); sut.exceptionCaught(context, new Exception()); assertThat(q).isEmpty(); assertThat(command.getException()).isNotNull(); verify(context).fireExceptionCaught(any(Exception.class)); }
private void finishUpdate( final NettyResponseFuture<?> future, Channel channel, boolean lastValidChunk) throws IOException { if (lastValidChunk && future.isKeepAlive()) { channels.drainChannel(channel, future); } else { if (future.isKeepAlive() && channel.isActive() && channels.offerToPool(channels.getPoolKey(future), channel)) { markAsDone(future, channel); return; } channels.finishChannel(channel); } markAsDone(future, channel); }
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; }
@Override public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { if (bufferedMode && outboundChannel.isActive()) { flushedBuffer = true; outboundChannel .writeAndFlush(interceptor.intercept(ctx, channelBuffer, logger)) .addListener( new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { if (future.isSuccess()) { channelBuffer.clear(); } else { future.channel().close(); } } }); } super.channelReadComplete(ctx); }
@Override public void userEventTriggered(final ChannelHandlerContext ctx, Object evt) throws Exception { if (evt instanceof IdleStateEvent) { IdleStateEvent e = (IdleStateEvent) evt; if (e.state() == IdleState.ALL_IDLE) { CouchbaseRequest keepAlive = createKeepAliveRequest(); if (keepAlive != null) { keepAlive.observable().subscribe(new KeepAliveResponseAction(ctx)); onKeepAliveFired(ctx, keepAlive); Channel channel = ctx.channel(); if (channel.isActive() && channel.isWritable()) { ctx.pipeline().writeAndFlush(keepAlive); } } } } else { super.userEventTriggered(ctx, evt); } }
@Override public void run() { try { logger.debug("starting cleanup"); for (Map.Entry<String, Channel> entry : connections.entrySet()) { Channel channel = entry.getValue(); Long lastMessage = channel.attr(lastMessageAttrKey).get(); if (System.currentTimeMillis() - lastMessage > FIVE_MINUTES) { channel.disconnect(); connections.remove(entry.getKey()); logger.debug("connection released for {}", entry.getKey()); } else if (!channel.isActive()) { connections.remove(entry.getKey()); logger.debug("connection released for {}", entry.getKey()); } } logger.debug("cleanup complete"); } catch (Exception e) { logger.error("exception while clean up", e); } }
@Override public void channelInactive(ChannelHandlerContext ctx) throws Exception { if (outboundChannel.isActive()) { outboundChannel.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE); } }
public boolean isActive() { return !timedOut && (channel.isOpen() || channel.isActive()); }