All Downloads are FREE. Search and download functionalities are using the official Maven repository.

io.edurt.datacap.pinot.org.jboss.netty.channel.SimpleChannelUpstreamHandler Maven / Gradle / Ivy

There is a newer version: 2024.03.7
Show newest version
/*
 * Copyright 2012 The Netty Project
 *
 * The Netty Project licenses this file to you under the Apache License,
 * version 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at:
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */
package io.edurt.datacap.pinot.org.jboss.netty.channel;

import io.edurt.datacap.pinot.org.jboss.netty.buffer.ChannelBuffer;
import io.edurt.datacap.pinot.org.jboss.netty.logging.InternalLogger;
import io.edurt.datacap.pinot.org.jboss.netty.logging.InternalLoggerFactory;

import java.util.List;


/**
 * A {@link ChannelUpstreamHandler} which provides an individual handler method
 * for each event type.  This handler down-casts the received upstream event
 * into more meaningful sub-type event and calls an appropriate handler method
 * with the down-cast event.  The names of the methods are identical to the
 * upstream event names, as introduced in the {@link ChannelEvent} documentation.
 * 

* Please use {@link SimpleChannelHandler} if you need to implement both * {@link ChannelUpstreamHandler} and {@link ChannelDownstreamHandler}. * *

Overriding the {@link #handleUpstream(ChannelHandlerContext, ChannelEvent) handleUpstream} method

*

* You can override the {@link #handleUpstream(ChannelHandlerContext, ChannelEvent) handleUpstream} * method just like overriding an ordinary Java method. Please make sure to * call {@code super.handleUpstream()} so that other handler methods are invoked * properly: *

*
public class MyChannelHandler extends {@link SimpleChannelUpstreamHandler} {
 *
 *     {@code @Override}
 *     public void handleUpstream({@link ChannelHandlerContext} ctx, {@link ChannelEvent} e) throws Exception {
 *
 *         // Log all channel state changes.
 *         if (e instanceof {@link ChannelStateEvent}) {
 *             logger.info("Channel state changed: " + e);
 *         }
 *
 *         super.handleUpstream(ctx, e);
 *     }
 * }
*/ public class SimpleChannelUpstreamHandler implements ChannelUpstreamHandler { private static final InternalLogger logger = InternalLoggerFactory.getInstance(SimpleChannelUpstreamHandler.class.getName()); /** * {@inheritDoc} Down-casts the received upstream event into more * meaningful sub-type event and calls an appropriate handler method with * the down-casted event. */ public void handleUpstream( ChannelHandlerContext ctx, ChannelEvent e) throws Exception { if (e instanceof MessageEvent) { messageReceived(ctx, (MessageEvent) e); } else if (e instanceof WriteCompletionEvent) { WriteCompletionEvent evt = (WriteCompletionEvent) e; writeComplete(ctx, evt); } else if (e instanceof ChildChannelStateEvent) { ChildChannelStateEvent evt = (ChildChannelStateEvent) e; if (evt.getChildChannel().isOpen()) { childChannelOpen(ctx, evt); } else { childChannelClosed(ctx, evt); } } else if (e instanceof ChannelStateEvent) { ChannelStateEvent evt = (ChannelStateEvent) e; switch (evt.getState()) { case OPEN: if (Boolean.TRUE.equals(evt.getValue())) { channelOpen(ctx, evt); } else { channelClosed(ctx, evt); } break; case BOUND: if (evt.getValue() != null) { channelBound(ctx, evt); } else { channelUnbound(ctx, evt); } break; case CONNECTED: if (evt.getValue() != null) { channelConnected(ctx, evt); } else { channelDisconnected(ctx, evt); } break; case INTEREST_OPS: channelInterestChanged(ctx, evt); break; default: ctx.sendUpstream(e); } } else if (e instanceof ExceptionEvent) { exceptionCaught(ctx, (ExceptionEvent) e); } else { ctx.sendUpstream(e); } } /** * Invoked when a message object (e.g: {@link ChannelBuffer}) was received * from a remote peer. */ public void messageReceived( ChannelHandlerContext ctx, MessageEvent e) throws Exception { ctx.sendUpstream(e); } /** * Invoked when an exception was raised by an I/O thread or a * {@link ChannelHandler}. */ public void exceptionCaught( ChannelHandlerContext ctx, ExceptionEvent e) throws Exception { ChannelPipeline pipeline = ctx.getPipeline(); ChannelHandler last = pipeline.getLast(); if (!(last instanceof ChannelUpstreamHandler) && ctx instanceof DefaultChannelPipeline) { // The names comes in the order of which they are insert when using DefaultChannelPipeline List names = ctx.getPipeline().getNames(); for (int i = names.size() - 1; i >= 0; i--) { ChannelHandler handler = ctx.getPipeline().get(names.get(i)); if (handler instanceof ChannelUpstreamHandler) { // find the last handler last = handler; break; } } } if (this == last) { logger.warn( "EXCEPTION, please implement " + getClass().getName() + ".exceptionCaught() for proper handling.", e.getCause()); } ctx.sendUpstream(e); } /** * Invoked when a {@link Channel} is open, but not bound nor connected. *
* * Be aware that this event is fired from within the I/O thread. You should never * execute any heavy operation in there as it will block the dispatching to other workers! */ public void channelOpen( ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { ctx.sendUpstream(e); } /** * Invoked when a {@link Channel} is open and bound to a local address, * but not connected. *
* * Be aware that this event is fired from within the I/O thread. You should never * execute any heavy operation in there as it will block the dispatching to other workers! */ public void channelBound( ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { ctx.sendUpstream(e); } /** * Invoked when a {@link Channel} is open, bound to a local address, and * connected to a remote address. *
* * Be aware that this event is fired from within the I/O thread. You should never * execute any heavy operation in there as it will block the dispatching to other workers! */ public void channelConnected( ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { ctx.sendUpstream(e); } /** * Invoked when a {@link Channel}'s {@link Channel#getInterestOps() interestOps} * was changed. */ public void channelInterestChanged( ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { ctx.sendUpstream(e); } /** * Invoked when a {@link Channel} was disconnected from its remote peer. */ public void channelDisconnected( ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { ctx.sendUpstream(e); } /** * Invoked when a {@link Channel} was unbound from the current local address. */ public void channelUnbound( ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { ctx.sendUpstream(e); } /** * Invoked when a {@link Channel} was closed and all its related resources * were released. */ public void channelClosed( ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception { ctx.sendUpstream(e); } /** * Invoked when something was written into a {@link Channel}. */ public void writeComplete( ChannelHandlerContext ctx, WriteCompletionEvent e) throws Exception { ctx.sendUpstream(e); } /** * Invoked when a child {@link Channel} was open. * (e.g. a server channel accepted a connection) */ public void childChannelOpen( ChannelHandlerContext ctx, ChildChannelStateEvent e) throws Exception { ctx.sendUpstream(e); } /** * Invoked when a child {@link Channel} was closed. * (e.g. the accepted connection was closed) */ public void childChannelClosed( ChannelHandlerContext ctx, ChildChannelStateEvent e) throws Exception { ctx.sendUpstream(e); } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy