Examples of io.netty.channel.ChannelPipeline

io.netty.channel.ChannelPipeline
sun.com/blueprints/corej2eepatterns/Patterns/InterceptingFilter.html">Intercepting Filter pattern to give a user full control over how an event is handled and how the {@link ChannelHandler}s in the pipeline interact with each other.
Creation of a pipeline
For each new channel, a new pipeline iscreated and attached to the channel. Once attached, the coupling between the channel and the pipeline is permanent; the channel cannot attach another pipeline to it nor detach the current pipeline from it. All of this is handled for you and you not need to take care of this.

How an event flows in a pipeline
The following diagram describes how I/O is processed by {@link ChannelHandler}s in a {@link ChannelPipeline} typically.A I/O-operation can be handled by either a {@link ChannelInboundHandler}or a {@link ChannelOutboundHandler} and be forwarded to the closesthandler by calling either one of the methods defined in the {@link ChannelInboundInvoker} interface for inbound I/O or by oneof the methods defined in the {@link ChannelOutboundInvoker} interfacefor outbound I/O. {@link ChannelPipeline} extends both of them.
```
 I/O Request via  {@link Channel} or{@link ChannelHandlerContext}| +----------------------------------------------------+-----------------+ |                           ChannelPipeline          |                 | |                                                   \|/                | |    +----------------------+            +-----------+------------+    | |    | Inbound Handler  N   |            | Outbound Handler  1    |    | |    +----------+-----------+            +-----------+------------+    | |              /|\                                   |                 | |               |                                   \|/                | |    +----------+-----------+            +-----------+------------+    | |    | Inbound Handler N-1  |            |   Outbound Handler  2  |    | |    +----------+-----------+            +-----------+------------+    | |              /|\                                   .                 | |               .                                    .                 | | [ {@link ChannelInboundInvoker}]   [ {@link ChannelOutboundInvoker}()] | |        [ method call]                    [method call]               | |               .                                    .                 | |               .                                   \|/                | |    +----------+-----------+            +-----------+------------+    | |    | Inbound Handler  2   |            | Outbound Handler M-1   |    | |    +----------+-----------+            +-----------+------------+    | |              /|\                                   |                 | |               |                                   \|/                | |    +----------+-----------+            +-----------+------------+    | |    | Inbound Handler  1   |            | Outbound Handler  M    |    | |    +----------+-----------+            +-----------+------------+    | |              /|\                                   |                 | +---------------+------------------------------------+-----------------+ |                                   \|/ +---------------+------------------------------------+-----------------+ |               |                                    |                 | |       [ Socket.read() ]                     [ Socket.write() ]       | |                                                                      | |  Netty Internal I/O Threads (Transport Implementation)               | +----------------------------------------------------------------------+ 
```
An upstream event is handled by the upstream handlers in the bottom-up direction as shown on the left side of the diagram. An upstream handler usually handles the inbound data generated by the I/O thread on the bottom of the diagram. The inbound data is often read from a remote peer via the actual input operation such as {@link InputStream#read(byte[])}. If an upstream event goes beyond the top upstream handler, it is discarded silently.
A downstream event is handled by the downstream handler in the top-down direction as shown on the right side of the diagram. A downstream handler usually generates or transforms the outbound traffic such as write requests. If a downstream event goes beyond the bottom downstream handler, it is handled by an I/O thread associated with the {@link Channel}. The I/O thread often performs the actual output operation such as {@link OutputStream#write(byte[])}.
For example, let us assume that we created the following pipeline:
```
 {@link ChannelPipeline} p = ...;p.addLast("1", new InboundHandlerA()); p.addLast("2", new InboundHandlerB()); p.addLast("3", new OutboundHandlerA()); p.addLast("4", new OutboundHandlerB()); p.addLast("5", new InboundOutboundHandlerX()); 
```
In the example above, the class whose name starts with {@code Upstream} meansit is an upstream handler. The class whose name starts with {@code Downstream} means it is a downstream handler.
In the given example configuration, the handler evaluation order is 1, 2, 3, 4, 5 when an event goes upstream. When an event goes downstream, the order is 5, 4, 3, 2, 1. On top of this principle, {@link ChannelPipeline} skipsthe evaluation of certain handlers to shorten the stack depth:
- 3 and 4 don't implement {@link ChannelInboundHandler}, and therefore the actual evaluation order of an upstream event will be: 1, 2, and 5.
- 1, 2, and 5 don't implement {@link ChannelOutboundHandler}, and therefore the actual evaluation order of a downstream event will be: 4 and 3.
- If 5 implements both {@link ChannelInboundHandler} and {@link ChannelOutboundHandler}, the evaluation order of an upstream and a downstream event could be 125 and 543 respectively.
Building a pipeline

A user is supposed to have one or more {@link ChannelHandler}s in a pipeline to receive I/O events (e.g. read) and to request I/O operations (e.g. write and close). For example, a typical server will have the following handlers in each channel's pipeline, but your mileage may vary depending on the complexity and characteristics of the protocol and business logic:
1. Protocol Decoder - translates binary data (e.g. {@link ByteBuf}) into a Java object.
2. Protocol Encoder - translates a Java object into binary data.
3. ExecutionHandler - applies a thread model.
4. Business Logic Handler - performs the actual business logic (e.g. database access).
and it could be represented as shown in the following example:
```
 {@link ChannelPipeline} pipeline = ...;pipeline.addLast("decoder", new MyProtocolDecoder()); pipeline.addLast("encoder", new MyProtocolEncoder()); pipeline.addLast("executor", new ExecutionHandler(...)); pipeline.addLast("handler", new MyBusinessLogicHandler()); 
```
Thread safety

A {@link ChannelHandler} can be added or removed at any time because a{@link ChannelPipeline} is thread safe. For example, you can insert anencryption handler when sensitive information is about to be exchanged, and remove it after the exchange.

        p.addLast("handler", new HttpSnoopServerHandler());
        p.removeAndForward(this);
    }


    private void switchToFactorial(ChannelHandlerContext ctx) {
        ChannelPipeline p = ctx.pipeline();
        p.addLast("decoder", new BigIntegerDecoder());
        p.addLast("encoder", new NumberEncoder());
        p.addLast("handler", new FactorialServerHandler());
        p.removeAndForward(this);
    }

View Full Code Here

        this.allowExtensions = allowExtensions;
    }


    @Override
    public void afterAdd(ChannelHandlerContext ctx) {
        ChannelPipeline cp = ctx.pipeline();
        if (cp.get(WebSocketServerProtocolHandshakeHandler.class) == null) {
            // Add the WebSocketHandshakeHandler before this one.
            ctx.pipeline().addBefore(ctx.name(), WebSocketServerProtocolHandshakeHandler.class.getName(),
                    new WebSocketServerProtocolHandshakeHandler(websocketPath, subprotocols, allowExtensions));
        }
    }

View Full Code Here

        super.messageReceived(ctx, frame);
    }


    @Override
    public void afterAdd(ChannelHandlerContext ctx) {
        ChannelPipeline cp = ctx.pipeline();
        if (cp.get(WebSocketClientProtocolHandshakeHandler.class) == null) {
            // Add the WebSocketClientProtocolHandshakeHandler before this one.
            ctx.pipeline().addBefore(ctx.name(), WebSocketClientProtocolHandshakeHandler.class.getName(),
                    new WebSocketClientProtocolHandshakeHandler(handshaker));
        }
    }

View Full Code Here

            if (!config().isAutoRead()) {
                // only remove readInterestOp if needed
                key.interestOps(key.interestOps() & ~readInterestOp);
            }


            final ChannelPipeline pipeline = pipeline();
            final ByteBuf byteBuf = pipeline.inboundByteBuffer();
            boolean closed = false;
            boolean read = false;
            boolean firedChannelReadSuspended = false;
            try {
                expandReadBuffer(byteBuf);
                loop: for (;;) {
                    int localReadAmount = doReadBytes(byteBuf);
                    if (localReadAmount > 0) {
                        read = true;
                    } else if (localReadAmount < 0) {
                        closed = true;
                        break;
                    }


                    switch (expandReadBuffer(byteBuf)) {
                    case 0:
                        // Read all - stop reading.
                        break loop;
                    case 1:
                        // Keep reading until everything is read.
                        break;
                    case 2:
                        // Let the inbound handler drain the buffer and continue reading.
                        if (read) {
                            read = false;
                            pipeline.fireInboundBufferUpdated();
                            if (!byteBuf.isWritable()) {
                                throw new IllegalStateException(
                                        "an inbound handler whose buffer is full must consume at " +
                                        "least one byte.");
                            }
                        }
                    }
                }
            } catch (Throwable t) {
                if (read) {
                    read = false;
                    pipeline.fireInboundBufferUpdated();
                }


                if (t instanceof IOException) {
                    closed = true;
                } else if (!closed) {
                    firedChannelReadSuspended = true;
                    pipeline.fireChannelReadSuspended();
                }
                pipeline().fireExceptionCaught(t);
            } finally {
                if (read) {
                    pipeline.fireInboundBufferUpdated();
                }


                if (closed) {
                    setInputShutdown();
                    if (isOpen()) {
                        if (Boolean.TRUE.equals(config().getOption(ChannelOption.ALLOW_HALF_CLOSURE))) {
                            key.interestOps(key.interestOps() & ~readInterestOp);
                            pipeline.fireUserEventTriggered(ChannelInputShutdownEvent.INSTANCE);
                        } else {
                            close(voidFuture());
                        }
                    }
                } else if (!firedChannelReadSuspended) {
                    pipeline.fireChannelReadSuspended();
                }
            }
        }

View Full Code Here

 * Creates a newly configured {@link ChannelPipeline} for a server-side channel.
 */
public class FactorialServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    public void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();


        // Enable stream compression (you can remove these two if unnecessary)
        pipeline.addLast("deflater", ZlibCodecFactory.newZlibEncoder(ZlibWrapper.GZIP));
        pipeline.addLast("inflater", ZlibCodecFactory.newZlibDecoder(ZlibWrapper.GZIP));


        // Add the number codec first,
        pipeline.addLast("decoder", new BigIntegerDecoder());
        pipeline.addLast("encoder", new NumberEncoder());


        // and then business logic.
        // Please note we create a handler for every new channel
        // because it has stateful properties.
        pipeline.addLast("handler", new FactorialServerHandler());
    }

View Full Code Here

    private static final StringDecoder DECODER = new StringDecoder();
    private static final StringEncoder ENCODER = new StringEncoder(BufType.BYTE);
    private static final TelnetClientHandler CLIENTHANDLER = new TelnetClientHandler();
    @Override
    public void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();


        // Add the text line codec combination first,
        pipeline.addLast("framer", new DelimiterBasedFrameDecoder(
                8192, Delimiters.lineDelimiter()));
        pipeline.addLast("decoder", DECODER);
        pipeline.addLast("encoder", ENCODER);


        // and then business logic.
        pipeline.addLast("handler", CLIENTHANDLER);
    }

View Full Code Here

    private static final StringEncoder ENCODER = new StringEncoder(BufType.BYTE);
    private static final TelnetServerHandler SERVERHANDLER = new TelnetServerHandler();


    @Override
    public void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();


        // Add the text line codec combination first,
        pipeline.addLast("framer", new DelimiterBasedFrameDecoder(
                8192, Delimiters.lineDelimiter()));
        // the encoder and decoder are static as these are sharable
        pipeline.addLast("decoder", DECODER);
        pipeline.addLast("encoder", ENCODER);


        // and then business logic.
        pipeline.addLast("handler", SERVERHANDLER);
    }

View Full Code Here

/**
 */
public class WebSocketSslServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    public void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();


        SSLEngine engine = WebSocketSslServerSslContext.getInstance().serverContext().createSSLEngine();
        engine.setUseClientMode(false);
        pipeline.addLast("ssl", new SslHandler(engine));


        pipeline.addLast("decoder", new HttpRequestDecoder());
        pipeline.addLast("aggregator", new HttpObjectAggregator(65536));
        pipeline.addLast("encoder", new HttpResponseEncoder());
        pipeline.addLast("handler", new WebSocketSslServerHandler());
    }

View Full Code Here


public class HttpSnoopServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    public void initChannel(SocketChannel ch) throws Exception {
        // Create a default pipeline implementation.
        ChannelPipeline p = ch.pipeline();


        // Uncomment the following line if you want HTTPS
        //SSLEngine engine = SecureChatSslContextFactory.getServerContext().createSSLEngine();
        //engine.setUseClientMode(false);
        //p.addLast("ssl", new SslHandler(engine));


        p.addLast("decoder", new HttpRequestDecoder());
        // Uncomment the following line if you don't want to handle HttpChunks.
        //p.addLast("aggregator", new HttpObjectAggregator(1048576));
        p.addLast("encoder", new HttpResponseEncoder());
        // Remove the following line if you don't want automatic content compression.
        //p.addLast("deflater", new HttpContentCompressor());
        p.addLast("handler", new HttpSnoopServerHandler());
    }

View Full Code Here

 */
public class SecureChatServerInitializer extends ChannelInitializer<SocketChannel> {


    @Override
    public void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();


        // Add SSL handler first to encrypt and decrypt everything.
        // In this example, we use a bogus certificate in the server side
        // and accept any invalid certificates in the client side.
        // You will need something more complicated to identify both
        // and server in the real world.
        //
        // Read SecureChatSslContextFactory
        // if you need client certificate authentication.


        SSLEngine engine =
            SecureChatSslContextFactory.getServerContext().createSSLEngine();
        engine.setUseClientMode(false);


        pipeline.addLast("ssl", new SslHandler(engine));


        // On top of the SSL handler, add the text line codec.
        pipeline.addLast("framer", new DelimiterBasedFrameDecoder(
                8192, Delimiters.lineDelimiter()));
        pipeline.addLast("decoder", new StringDecoder());
        pipeline.addLast("encoder", new StringEncoder(BufType.BYTE));


        // and then business logic.
        pipeline.addLast("handler", new SecureChatServerHandler());
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of io.netty.channel.ChannelPipeline

com.basho.riak.client.core.RiakNodeTest

com.corundumstudio.socketio.SocketIOChannelInitializer

cpw.mods.fml.common.network.internal.FMLNetworkHandler

io.netty.bootstrap.Bootstrap

io.netty.bootstrap.ClientBootstrap

io.netty.bootstrap.ConnectionlessBootstrap

io.netty.bootstrap.ServerBootstrap

io.netty.channel.embedded.EmbeddedChannel

io.netty.channel.embedded.EmbeddedChannelTest

io.netty.channel.epoll.EpollSocketChannel$EpollSocketUnsafe

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of io.netty.channel.ChannelPipeline

Creation of a pipeline

How an event flows in a pipeline

Building a pipeline

Thread safety

Related Classes of io.netty.channel.ChannelPipeline