virajjasani commented on PR #4596:
URL: https://github.com/apache/hbase/pull/4596#issuecomment-1174655400

   `ByteToMessageDecoder`:
   
   ```
       @Override
       public void channelRead(ChannelHandlerContext ctx, Object msg) throws 
Exception {
           if (msg instanceof ByteBuf) {
               selfFiredChannelRead = true;
               CodecOutputList out = CodecOutputList.newInstance();
               try {
                   first = cumulation == null;
                   cumulation = cumulator.cumulate(ctx.alloc(),
                           first ? Unpooled.EMPTY_BUFFER : cumulation, 
(ByteBuf) msg);
                   callDecode(ctx, cumulation, out);   <====================== 
Line 279
               } catch (DecoderException e) {
                   throw e;
               } catch (Exception e) {
                   throw new DecoderException(e);
               } finally {
                   try {
                       if (cumulation != null && !cumulation.isReadable()) {
                           numReads = 0;
                           cumulation.release();
                           cumulation = null;
                       } else if (++numReads >= discardAfterReads) {
   ...
   ...
   ...
   ```
   
   ```
       protected void callDecode(ChannelHandlerContext ctx, ByteBuf in, 
List<Object> out) {
           try {
               while (in.isReadable()) {
                   final int outSize = out.size();
   
                   if (outSize > 0) {
                       fireChannelRead(ctx, out, outSize);
                       out.clear();
   
                       // Check if this handler was removed before continuing 
with decoding.
                       // If it was removed, it is not safe to continue to 
operate on the buffer.
                       //
                       // See:
                       // - https://github.com/netty/netty/issues/4635
                       if (ctx.isRemoved()) {
                           break;
                       }
                   }
   
                   int oldInputLength = in.readableBytes();
                   decodeRemovalReentryProtection(ctx, in, out);  
<============== (Line 449)
   
                   // Check if this handler was removed before continuing the 
loop.
                   // If it was removed, it is not safe to continue to operate 
on the buffer.
                   //
                   // See https://github.com/netty/netty/issues/1664
                   if (ctx.isRemoved()) {
                       break;
                   }
   ...
   ...
   ...
   ```
   
   ```
       final void decodeRemovalReentryProtection(ChannelHandlerContext ctx, 
ByteBuf in, List<Object> out)
               throws Exception {
           decodeState = STATE_CALLING_CHILD_DECODE;
           try {
               decode(ctx, in, out);        <==================== (Line 510)
           } finally {
               boolean removePending = decodeState == 
STATE_HANDLER_REMOVED_PENDING;
               decodeState = STATE_INIT;
               if (removePending) {
                   fireChannelRead(ctx, out, out.size());
                   out.clear();
                   handlerRemoved(ctx);
               }
           }
       }
   ```


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to