Java ProtobufUtil.mergeDelimitedFrom方法代码示例

import org.apache.hadoop.hbase.protobuf.ProtobufUtil; //导入方法依赖的package包/类
@Override
public Result deserialize(Result mutation) throws IOException {
  ClientProtos.Result.Builder builder = ClientProtos.Result.newBuilder();
  ProtobufUtil.mergeDelimitedFrom(builder, in);
  ClientProtos.Result proto = builder.build();
  return ProtobufUtil.toResult(proto);
}
 

import org.apache.hadoop.hbase.protobuf.ProtobufUtil; //导入方法依赖的package包/类
@Override
public Mutation deserialize(Mutation mutation) throws IOException {
  ClientProtos.MutationProto.Builder builder = ClientProtos.MutationProto.newBuilder();
  ProtobufUtil.mergeDelimitedFrom(builder, in);
  ClientProtos.MutationProto proto = builder.build();
  return ProtobufUtil.toMutation(proto);
}
 

import org.apache.hadoop.hbase.protobuf.ProtobufUtil; //导入方法依赖的package包/类
protected void readResponse() {
  if (shouldCloseConnection.get()) return;
  Call call = null;
  boolean expectedCall = false;
  try {
    // See HBaseServer.Call.setResponse for where we write out the response.
    // Total size of the response.  Unused.  But have to read it in anyways.
    int totalSize = in.readInt();

    // Read the header
    ResponseHeader responseHeader = ResponseHeader.parseDelimitedFrom(in);
    int id = responseHeader.getCallId();
    call = calls.remove(id); // call.done have to be set before leaving this method
    expectedCall = (call != null && !call.done);
    if (!expectedCall) {
      // So we got a response for which we have no corresponding 'call' here on the client-side.
      // We probably timed out waiting, cleaned up all references, and now the server decides
      // to return a response.  There is nothing we can do w/ the response at this stage. Clean
      // out the wire of the response so its out of the way and we can get other responses on
      // this connection.
      int readSoFar = IPCUtil.getTotalSizeWhenWrittenDelimited(responseHeader);
      int whatIsLeftToRead = totalSize - readSoFar;
      IOUtils.skipFully(in, whatIsLeftToRead);
      if (call != null) {
        call.callStats.setResponseSizeBytes(totalSize);
        call.callStats.setCallTimeMs(
            EnvironmentEdgeManager.currentTime() - call.callStats.getStartTime());
      }
      return;
    }
    if (responseHeader.hasException()) {
      ExceptionResponse exceptionResponse = responseHeader.getException();
      RemoteException re = createRemoteException(exceptionResponse);
      call.setException(re);
      call.callStats.setResponseSizeBytes(totalSize);
      call.callStats.setCallTimeMs(
          EnvironmentEdgeManager.currentTime() - call.callStats.getStartTime());
      if (isFatalConnectionException(exceptionResponse)) {
        markClosed(re);
      }
    } else {
      Message value = null;
      if (call.responseDefaultType != null) {
        Builder builder = call.responseDefaultType.newBuilderForType();
        ProtobufUtil.mergeDelimitedFrom(builder, in);
        value = builder.build();
      }
      CellScanner cellBlockScanner = null;
      if (responseHeader.hasCellBlockMeta()) {
        int size = responseHeader.getCellBlockMeta().getLength();
        byte [] cellBlock = new byte[size];
        IOUtils.readFully(this.in, cellBlock, 0, cellBlock.length);
        cellBlockScanner = ipcUtil.createCellScanner(this.codec, this.compressor, cellBlock);
      }
      call.setResponse(value, cellBlockScanner);
      call.callStats.setResponseSizeBytes(totalSize);
      call.callStats.setCallTimeMs(
          EnvironmentEdgeManager.currentTime() - call.callStats.getStartTime());
    }
  } catch (IOException e) {
    if (expectedCall) call.setException(e);
    if (e instanceof SocketTimeoutException) {
      // Clean up open calls but don't treat this as a fatal condition,
      // since we expect certain responses to not make it by the specified
      // {@link ConnectionId#rpcTimeout}.
      if (LOG.isTraceEnabled()) LOG.trace("ignored", e);
    } else {
      // Treat this as a fatal condition and close this connection
      markClosed(e);
    }
  } finally {
    cleanupCalls(false);
  }
}
 

import org.apache.hadoop.hbase.protobuf.ProtobufUtil; //导入方法依赖的package包/类
@Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
  ByteBuf inBuffer = (ByteBuf) msg;
  ByteBufInputStream in = new ByteBufInputStream(inBuffer);
  int totalSize = inBuffer.readableBytes();
  try {
    // Read the header
    RPCProtos.ResponseHeader responseHeader = RPCProtos.ResponseHeader.parseDelimitedFrom(in);
    int id = responseHeader.getCallId();
    AsyncCall call = channel.removePendingCall(id);
    if (call == null) {
      // So we got a response for which we have no corresponding 'call' here on the client-side.
      // We probably timed out waiting, cleaned up all references, and now the server decides
      // to return a response.  There is nothing we can do w/ the response at this stage. Clean
      // out the wire of the response so its out of the way and we can get other responses on
      // this connection.
      int readSoFar = IPCUtil.getTotalSizeWhenWrittenDelimited(responseHeader);
      int whatIsLeftToRead = totalSize - readSoFar;

      // This is done through a Netty ByteBuf which has different behavior than InputStream.
      // It does not return number of bytes read but will update pointer internally and throws an
      // exception when too many bytes are to be skipped.
      inBuffer.skipBytes(whatIsLeftToRead);
      return;
    }

    if (responseHeader.hasException()) {
      RPCProtos.ExceptionResponse exceptionResponse = responseHeader.getException();
      RemoteException re = createRemoteException(exceptionResponse);
      if (exceptionResponse.getExceptionClassName().
          equals(FatalConnectionException.class.getName())) {
        channel.close(re);
      } else {
        call.setFailed(re);
      }
    } else {
      Message value = null;
      // Call may be null because it may have timedout and been cleaned up on this side already
      if (call.responseDefaultType != null) {
        Message.Builder builder = call.responseDefaultType.newBuilderForType();
        ProtobufUtil.mergeDelimitedFrom(builder, in);
        value = builder.build();
      }
      CellScanner cellBlockScanner = null;
      if (responseHeader.hasCellBlockMeta()) {
        int size = responseHeader.getCellBlockMeta().getLength();
        byte[] cellBlock = new byte[size];
        inBuffer.readBytes(cellBlock, 0, cellBlock.length);
        cellBlockScanner = channel.client.createCellScanner(cellBlock);
      }
      call.setSuccess(value, cellBlockScanner);
      call.callStats.setResponseSizeBytes(totalSize);
    }
  } catch (IOException e) {
    // Treat this as a fatal condition and close this connection
    channel.close(e);
  } finally {
    inBuffer.release();
  }
}