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

com.datastax.driver.core.SegmentToFrameDecoder Maven / Gradle / Ivy

Go to download

A driver for Apache Cassandra 1.2+ that works exclusively with the Cassandra Query Language version 3 (CQL3) and Cassandra's binary protocol.

There is a newer version: 4.0.0
Show newest version
/*
 * Copyright DataStax, Inc.
 *
 * Licensed 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 com.datastax.driver.core;

import com.datastax.driver.core.Frame.Header;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.buffer.CompositeByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageDecoder;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Converts the segments decoded by {@link BytesToSegmentDecoder} into legacy frames understood by
 * the rest of the driver.
 */
class SegmentToFrameDecoder extends MessageToMessageDecoder {

  private static final Logger logger = LoggerFactory.getLogger(SegmentToFrameDecoder.class);

  // Accumulated state when we are reading a sequence of slices
  private Header pendingHeader;
  private final List accumulatedSlices = new ArrayList();
  private int accumulatedLength;

  SegmentToFrameDecoder() {
    super(Segment.class);
  }

  @Override
  protected void decode(ChannelHandlerContext ctx, Segment segment, List out) {
    if (segment.isSelfContained()) {
      decodeSelfContained(segment, out);
    } else {
      decodeSlice(segment, ctx.alloc(), out);
    }
  }

  private void decodeSelfContained(Segment segment, List out) {
    ByteBuf payload = segment.getPayload();
    int frameCount = 0;
    do {
      Header header = Header.decode(payload);
      ByteBuf body = payload.readSlice(header.bodyLength);
      body.retain();
      out.add(new Frame(header, body));
      frameCount += 1;
    } while (payload.isReadable());
    payload.release();
    logger.trace("Decoded self-contained segment into {} frame(s)", frameCount);
  }

  private void decodeSlice(Segment segment, ByteBufAllocator allocator, List out) {
    assert pendingHeader != null ^ (accumulatedSlices.isEmpty() && accumulatedLength == 0);
    ByteBuf payload = segment.getPayload();
    if (pendingHeader == null) { // first slice
      pendingHeader = Header.decode(payload); // note: this consumes the header data
    }
    accumulatedSlices.add(payload);
    accumulatedLength += payload.readableBytes();
    logger.trace(
        "StreamId {}: decoded slice {}, {}/{} bytes",
        pendingHeader.streamId,
        accumulatedSlices.size(),
        accumulatedLength,
        pendingHeader.bodyLength);
    assert accumulatedLength <= pendingHeader.bodyLength;
    if (accumulatedLength == pendingHeader.bodyLength) {
      // We've received enough data to reassemble the whole message
      CompositeByteBuf body = allocator.compositeBuffer(accumulatedSlices.size());
      body.addComponents(true, accumulatedSlices);
      out.add(new Frame(pendingHeader, body));
      // Reset our state
      pendingHeader = null;
      accumulatedSlices.clear();
      accumulatedLength = 0;
    }
  }
}
    

    

    

            

    

            



    
    






    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy