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.

        }


        @Override
        void epollInReady() {
            final ChannelConfig config = config();
            final ChannelPipeline pipeline = pipeline();
            final ByteBufAllocator allocator = config.getAllocator();
            RecvByteBufAllocator.Handle allocHandle = unsafe().recvBufAllocHandle();


            ByteBuf byteBuf = null;
            boolean close = false;
            try {
                int totalReadAmount = 0;
                for (;;) {
                    // we use a direct buffer here as the native implementations only be able
                    // to handle direct buffers.
                    byteBuf = allocHandle.allocate(allocator);
                    int writable = byteBuf.writableBytes();
                    int localReadAmount = doReadBytes(byteBuf);
                    if (localReadAmount <= 0) {
                        // not was read release the buffer
                        byteBuf.release();
                        close = localReadAmount < 0;
                        break;
                    }
                    readPending = false;
                    pipeline.fireChannelRead(byteBuf);
                    byteBuf = null;


                    if (totalReadAmount >= Integer.MAX_VALUE - localReadAmount) {
                        allocHandle.record(totalReadAmount);


                        // Avoid overflow.
                        totalReadAmount = localReadAmount;
                    } else {
                        totalReadAmount += localReadAmount;
                    }


                    if (localReadAmount < writable) {
                        // Read less than what the buffer can hold,
                        // which might mean we drained the recv buffer completely.
                        break;
                    }
                }
                pipeline.fireChannelReadComplete();
                allocHandle.record(totalReadAmount);


                if (close) {
                    closeOnRead(pipeline);
                    close = false;

View Full Code Here

             * Since SSE is an endless stream, we can never reuse a connection and hence as soon as SSE traffic is
             * received, the connection is marked as discardable on close.
             */
            ctx.channel().attr(ClientRequestResponseConverter.DISCARD_CONNECTION).set(true); // SSE traffic should always discard connection on close.


            ChannelPipeline pipeline = ctx.channel().pipeline();
            if (!HttpHeaders.isTransferEncodingChunked((HttpResponse) msg)) {
                pipeline.addFirst(SSE_DECODER_HANDLER_NAME, new ServerSentEventDecoder());
                /*
                 * If there are buffered messages in the previous handler at the time this message is read, we would
                 * not be able to convert the content into an SseEvent. For this reason, we also add the decoder after
                 * this handler, so that we can handle the buffered messages.
                 * See the class level javadoc for more details.
                 */
                pipeline.addAfter(NAME, SSE_DECODER_POST_INBOUND_HANDLER, new ServerSentEventDecoder());
            } else {
                pipeline.addAfter(NAME, SSE_DECODER_HANDLER_NAME, new ServerSentEventDecoder());
            }
            ctx.fireChannelRead(msg);
        } else if (msg instanceof LastHttpContent) {
            LastHttpContent lastHttpContent = (LastHttpContent) msg;

View Full Code Here

                        eventsSubject.onEvent(ClientMetricsEvent.CONNECT_FAILED, Clock.onEndMillis(startTimeMillis),
                                              future.cause());
                        subscriber.onError(future.cause());
                    } else {
                        eventsSubject.onEvent(ClientMetricsEvent.CONNECT_SUCCESS, Clock.onEndMillis(startTimeMillis));
                        ChannelPipeline pipeline = future.channel().pipeline();
                        final ObservableConnection<I, O> newConnection = connectionFactory.newConnection(future.channel());
                        ChannelHandler lifecycleHandler = pipeline.get(RxRequiredConfigurator.CONN_LIFECYCLE_HANDLER_NAME);
                        if (null == lifecycleHandler) {
                            onNewConnection(newConnection, subscriber);
                        } else {
                            @SuppressWarnings("unchecked")
                            ConnectionLifecycleHandler<I, O> handler = (ConnectionLifecycleHandler<I, O>) lifecycleHandler;
                            SslHandler sslHandler = pipeline.get(SslHandler.class);
                            if (null == sslHandler) {
                                handler.setConnection(newConnection);
                                onNewConnection(newConnection, subscriber);
                            } else {
                                sslHandler.handshakeFuture().addListener(new GenericFutureListener<Future<? super Channel>>() {

View Full Code Here

     * Shutdown this client and close all open connections. The client should be
     * discarded after calling shutdown.
     */
    public void shutdown() {
        for (Channel c : channels) {
            ChannelPipeline pipeline = c.pipeline();
            RedisAsyncConnection<?, ?> connection = pipeline.get(RedisAsyncConnection.class);
            connection.close();
        }
        ChannelGroupFuture future = channels.close();
        future.awaitUninterruptibly();
    }

View Full Code Here

            this.originalHandler = originalHandler;
        }


        @Override
        public Observable<Void> handle(final ObservableConnection<I, O> connection) {
            final ChannelPipeline p = connection.getChannel().pipeline();
            ChannelHandlerContext hctx = p.context(WebSocketServerHandler.class);
            if (hctx != null) {
                WebSocketServerHandler handler = p.get(WebSocketServerHandler.class);
                final PublishSubject<Void> subject = PublishSubject.create();
                handler.addHandshakeFinishedListener(new ChannelFutureListener() {
                    @Override
                    public void operationComplete(ChannelFuture future) throws Exception {
                        originalHandler.handle(connection).subscribe(subject);

View Full Code Here

                    originalSubscriber.onError(e);
                }


                @Override
                public void onNext(final ObservableConnection<T, T> connection) {
                    final ChannelPipeline p = connection.getChannel().pipeline();
                    ChannelHandlerContext hctx = p.context(WebSocketClientHandler.class);
                    if (hctx != null) {
                        WebSocketClientHandler handler = p.get(WebSocketClientHandler.class);
                        handler.addHandshakeFinishedListener(new ChannelFutureListener() {
                            @Override
                            public void operationComplete(ChannelFuture future) throws Exception {
                                originalSubscriber.onNext(connection);
                                originalSubscriber.onCompleted();

View Full Code Here

        ctx.fireChannelActive();
    }


    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        ChannelPipeline pipeLine = channel.pipeline();
        CommandHandler<?, ?> handler = pipeLine.get(CommandHandler.class);
        RedisAsyncConnection<?, ?> connection = pipeLine.get(RedisAsyncConnection.class);
        if (connection.isReconnect()) {
            EventLoop loop = ctx.channel().eventLoop();
            reconnect(loop, handler, connection);
        }
        ctx.fireChannelInactive();

View Full Code Here

            ctx.fireChannelRead(msg);
        }
    }


    private void updatePipeline(ChannelHandlerContext ctx) {
        ChannelPipeline p = ctx.pipeline();
        ChannelHandlerContext nettyEncoderCtx = p.context(WebSocketFrameEncoder.class);
        p.addAfter(nettyEncoderCtx.name(), "websocket-write-metrics", new ServerWriteMetricsHandler(eventsSubject));
        ChannelHandlerContext nettyDecoderCtx = p.context(WebSocketFrameDecoder.class);
        p.addAfter(nettyDecoderCtx.name(), "websocket-read-metrics", new ServerReadMetricsHandler(eventsSubject));
        if (messageAggregator) {
            p.addAfter("websocket-read-metrics", "websocket-frame-aggregator", new WebSocketFrameAggregator(maxFramePayloadLength));
        }
        p.remove(this);
    }

View Full Code Here

            ctx.close();
            return;
        }
        eventsSubject.onEvent(WebSocketClientMetricsEvent.HANDSHAKE_SUCCESS, Clock.onEndMillis(handshakeStartTime));


        ChannelPipeline p = ctx.pipeline();
        ChannelHandlerContext nettyDecoderCtx = p.context(WebSocketFrameDecoder.class);
        p.addAfter(nettyDecoderCtx.name(), "websocket-read-metrics", new ClientReadMetricsHandler(eventsSubject));
        ChannelHandlerContext nettyEncoderCtx = p.context(WebSocketFrameEncoder.class);
        p.addAfter(nettyEncoderCtx.name(), "websocket-write-metrics", new ClientWriteMetricsHandler(eventsSubject));
        if (messageAggregation) {
            p.addAfter("websocket-read-metrics", "websocket-frame-aggregator", new WebSocketFrameAggregator(maxFramePayloadLength));
        }
        p.remove(HttpObjectAggregator.class);
        p.remove(this);


        handshakeFuture.setSuccess();
    }

View Full Code Here

      }


      @Override
      public void initChannel(Channel channel) throws Exception {
         // Create a default pipeline implementation.
         ChannelPipeline pipeline = channel.pipeline();


         pipeline.addLast("decoder", new HttpRequestDecoder());
         pipeline.addLast("aggregator", new HttpObjectAggregator(65536));
         pipeline.addLast("encoder", new HttpResponseEncoder());
         pipeline.addLast("handler", new WebSocketServerHandler(cacheContainer, operationHandlers, startedCaches));
      }

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