Java CellUtil.createCellScanner方法代码示例

import org.apache.hadoop.hbase.CellUtil; //导入方法依赖的package包/类
@Ignore
@Test
public void testRpcScheduler() throws IOException, InterruptedException {
  PriorityFunction qosFunction = mock(PriorityFunction.class);
  Abortable abortable = new AbortServer();
  RpcScheduler scheduler = new SimpleRpcScheduler(CONF, 2, 0, 0, qosFunction, abortable, 0);
  RpcServer rpcServer = new TestRpcServer(scheduler);
  RpcClientImpl client = new RpcClientImpl(CONF, HConstants.CLUSTER_ID_DEFAULT);
  try {
    rpcServer.start();
    MethodDescriptor md = SERVICE.getDescriptorForType().findMethodByName("echo");
    EchoRequestProto param = EchoRequestProto.newBuilder().setMessage("hello").build();
    PayloadCarryingRpcController controller =
        new PayloadCarryingRpcController(CellUtil.createCellScanner(ImmutableList.of(CELL)));
    InetSocketAddress address = rpcServer.getListenerAddress();
    if (address == null) {
      throw new IOException("Listener channel is closed");
    }
    client.call(controller, md, param, md.getOutputType().toProto(), User.getCurrent(),
        address, new MetricsConnection.CallStats());
  } catch (Throwable e) {
    assert(abortable.isAborted() == true);
  } finally {
    rpcServer.stop();
  }
}
 

import org.apache.hadoop.hbase.CellUtil; //导入方法依赖的package包/类
static CellScanner getSizedCellScanner(final Cell [] cells) {
  int size = -1;
  for (Cell cell: cells) {
    size += CellUtil.estimatedSerializedSizeOf(cell);
  }
  final int totalSize = ClassSize.align(size);
  final CellScanner cellScanner = CellUtil.createCellScanner(cells);
  return new SizedCellScanner() {
    @Override
    public long heapSize() {
      return totalSize;
    }

    @Override
    public Cell current() {
      return cellScanner.current();
    }

    @Override
    public boolean advance() throws IOException {
      return cellScanner.advance();
    }
  };
}
 

import org.apache.hadoop.hbase.CellUtil; //导入方法依赖的package包/类
@Override
public TestProtos.EchoResponseProto echo(RpcController controller,
                                         TestProtos.EchoRequestProto request)
    throws ServiceException {
  if (controller instanceof PayloadCarryingRpcController) {
    PayloadCarryingRpcController pcrc = (PayloadCarryingRpcController) controller;
    // If cells, scan them to check we are able to iterate what we were given and since
    // this is
    // an echo, just put them back on the controller creating a new block. Tests our
    // block
    // building.
    CellScanner cellScanner = pcrc.cellScanner();
    List<Cell> list = null;
    if (cellScanner != null) {
      list = new ArrayList<Cell>();
      try {
        while (cellScanner.advance()) {
          list.add(cellScanner.current());
        }
      } catch (IOException e) {
        throw new ServiceException(e);
      }
    }
    cellScanner = CellUtil.createCellScanner(list);
    ((PayloadCarryingRpcController) controller).setCellScanner(cellScanner);
  }
  return TestProtos.EchoResponseProto.newBuilder()
      .setMessage(request.getMessage()).build();
}
 

import org.apache.hadoop.hbase.CellUtil; //导入方法依赖的package包/类
@Override
public EchoResponseProto echo(RpcController controller, EchoRequestProto request)
    throws ServiceException {
  if (controller instanceof PayloadCarryingRpcController) {
    PayloadCarryingRpcController pcrc = (PayloadCarryingRpcController) controller;
    // If cells, scan them to check we are able to iterate what we were given and since
    // this is
    // an echo, just put them back on the controller creating a new block. Tests our
    // block
    // building.
    CellScanner cellScanner = pcrc.cellScanner();
    List<Cell> list = null;
    if (cellScanner != null) {
      list = new ArrayList<Cell>();
      try {
        while (cellScanner.advance()) {
          list.add(cellScanner.current());
        }
      } catch (IOException e) {
        throw new ServiceException(e);
      }
    }
    cellScanner = CellUtil.createCellScanner(list);
    ((PayloadCarryingRpcController) controller).setCellScanner(cellScanner);
  }
  return EchoResponseProto.newBuilder().setMessage(request.getMessage()).build();
}
 

import org.apache.hadoop.hbase.CellUtil; //导入方法依赖的package包/类
static void doBuildCellBlockUndoCellBlock(final IPCUtil util, final Codec codec,
  final CompressionCodec compressor, final int count, final int size, final boolean sized)
throws IOException {
  Cell [] cells = getCells(count, size);
  CellScanner cellScanner = sized? getSizedCellScanner(cells):
    CellUtil.createCellScanner(Arrays.asList(cells).iterator());
  ByteBuffer bb = util.buildCellBlock(codec, compressor, cellScanner);
  cellScanner = util.createCellScanner(codec, compressor, bb.array(), 0, bb.limit());
  int i = 0;
  while (cellScanner.advance()) {
    i++;
  }
  assertEquals(count, i);
}
 

import org.apache.hadoop.hbase.CellUtil; //导入方法依赖的package包/类
public static void main(String[] args) throws IOException, SecurityException,
    NoSuchMethodException, InterruptedException {
  if (args.length != 2) {
    System.out.println("Usage: TestAsyncIPC <CYCLES> <CELLS_PER_CYCLE>");
    return;
  }
  // ((Log4JLogger)HBaseServer.LOG).getLogger().setLevel(Level.INFO);
  // ((Log4JLogger)HBaseClient.LOG).getLogger().setLevel(Level.INFO);
  int cycles = Integer.parseInt(args[0]);
  int cellcount = Integer.parseInt(args[1]);
  Configuration conf = HBaseConfiguration.create();
  TestRpcServer rpcServer = new TestRpcServer();
  MethodDescriptor md = SERVICE.getDescriptorForType().findMethodByName("echo");
  EchoRequestProto param = EchoRequestProto.newBuilder().setMessage("hello").build();
  AsyncRpcClient client = new AsyncRpcClient(conf);
  KeyValue kv = BIG_CELL;
  Put p = new Put(CellUtil.cloneRow(kv));
  for (int i = 0; i < cellcount; i++) {
    p.add(kv);
  }
  RowMutations rm = new RowMutations(CellUtil.cloneRow(kv));
  rm.add(p);
  try {
    rpcServer.start();
    InetSocketAddress address = rpcServer.getListenerAddress();
    if (address == null) {
      throw new IOException("Listener channel is closed");
    }
    long startTime = System.currentTimeMillis();
    User user = User.getCurrent();
    for (int i = 0; i < cycles; i++) {
      List<CellScannable> cells = new ArrayList<CellScannable>();
      // Message param = RequestConverter.buildMultiRequest(HConstants.EMPTY_BYTE_ARRAY, rm);
      ClientProtos.RegionAction.Builder builder =
          RequestConverter.buildNoDataRegionAction(HConstants.EMPTY_BYTE_ARRAY, rm, cells,
            RegionAction.newBuilder(), ClientProtos.Action.newBuilder(),
            MutationProto.newBuilder());
      builder.setRegion(RegionSpecifier
          .newBuilder()
          .setType(RegionSpecifierType.REGION_NAME)
          .setValue(
            ByteString.copyFrom(HRegionInfo.FIRST_META_REGIONINFO.getEncodedNameAsBytes())));
      if (i % 100000 == 0) {
        LOG.info("" + i);
        // Uncomment this for a thread dump every so often.
        // ReflectionUtils.printThreadInfo(new PrintWriter(System.out),
        // "Thread dump " + Thread.currentThread().getName());
      }
      PayloadCarryingRpcController pcrc =
          new PayloadCarryingRpcController(CellUtil.createCellScanner(cells));
      // Pair<Message, CellScanner> response =
      client.call(pcrc, md, builder.build(), param, user, address,
          new MetricsConnection.CallStats());
      /*
       * int count = 0; while (p.getSecond().advance()) { count++; } assertEquals(cells.size(),
       * count);
       */
    }
    LOG.info("Cycled " + cycles + " time(s) with " + cellcount + " cell(s) in "
        + (System.currentTimeMillis() - startTime) + "ms");
  } finally {
    client.close();
    rpcServer.stop();
  }
}
 

import org.apache.hadoop.hbase.CellUtil; //导入方法依赖的package包/类
public static void main(String[] args) throws IOException, SecurityException,
    NoSuchMethodException, InterruptedException {
  if (args.length != 2) {
    System.out.println("Usage: TestIPC <CYCLES> <CELLS_PER_CYCLE>");
    return;
  }
  // ((Log4JLogger)HBaseServer.LOG).getLogger().setLevel(Level.INFO);
  // ((Log4JLogger)HBaseClient.LOG).getLogger().setLevel(Level.INFO);
  int cycles = Integer.parseInt(args[0]);
  int cellcount = Integer.parseInt(args[1]);
  Configuration conf = HBaseConfiguration.create();
  TestRpcServer rpcServer = new TestRpcServer();
  MethodDescriptor md = SERVICE.getDescriptorForType().findMethodByName("echo");
  EchoRequestProto param = EchoRequestProto.newBuilder().setMessage("hello").build();
  RpcClientImpl client = new RpcClientImpl(conf, HConstants.CLUSTER_ID_DEFAULT);
  KeyValue kv = BIG_CELL;
  Put p = new Put(CellUtil.cloneRow(kv));
  for (int i = 0; i < cellcount; i++) {
    p.add(kv);
  }
  RowMutations rm = new RowMutations(CellUtil.cloneRow(kv));
  rm.add(p);
  try {
    rpcServer.start();
    long startTime = System.currentTimeMillis();
    User user = User.getCurrent();
    InetSocketAddress address = rpcServer.getListenerAddress();
    if (address == null) {
      throw new IOException("Listener channel is closed");
    }
    for (int i = 0; i < cycles; i++) {
      List<CellScannable> cells = new ArrayList<CellScannable>();
      // Message param = RequestConverter.buildMultiRequest(HConstants.EMPTY_BYTE_ARRAY, rm);
      ClientProtos.RegionAction.Builder builder =
          RequestConverter.buildNoDataRegionAction(HConstants.EMPTY_BYTE_ARRAY, rm, cells,
            RegionAction.newBuilder(), ClientProtos.Action.newBuilder(),
            MutationProto.newBuilder());
      builder.setRegion(RegionSpecifier
          .newBuilder()
          .setType(RegionSpecifierType.REGION_NAME)
          .setValue(
            ByteString.copyFrom(HRegionInfo.FIRST_META_REGIONINFO.getEncodedNameAsBytes())));
      if (i % 100000 == 0) {
        LOG.info("" + i);
        // Uncomment this for a thread dump every so often.
        // ReflectionUtils.printThreadInfo(new PrintWriter(System.out),
        // "Thread dump " + Thread.currentThread().getName());
      }
      PayloadCarryingRpcController pcrc =
          new PayloadCarryingRpcController(CellUtil.createCellScanner(cells));
      // Pair<Message, CellScanner> response =
      client.call(pcrc, md, builder.build(), param, user, address,
          new MetricsConnection.CallStats());
      /*
       * int count = 0; while (p.getSecond().advance()) { count++; } assertEquals(cells.size(),
       * count);
       */
    }
    LOG.info("Cycled " + cycles + " time(s) with " + cellcount + " cell(s) in "
        + (System.currentTimeMillis() - startTime) + "ms");
  } finally {
    client.close();
    rpcServer.stop();
  }
}
 

import org.apache.hadoop.hbase.CellUtil; //导入方法依赖的package包/类
/**
 * It is hard to verify the compression is actually happening under the wraps. Hope that if
 * unsupported, we'll get an exception out of some time (meantime, have to trace it manually to
 * confirm that compression is happening down in the client and server).
 * @throws IOException
 * @throws InterruptedException
 * @throws SecurityException
 * @throws NoSuchMethodException
 */
@Test
public void testCompressCellBlock() throws IOException, InterruptedException, SecurityException,
    NoSuchMethodException, ServiceException {
  Configuration conf = new Configuration(HBaseConfiguration.create());
  conf.set("hbase.client.rpc.compressor", GzipCodec.class.getCanonicalName());
  List<Cell> cells = new ArrayList<Cell>();
  int count = 3;
  for (int i = 0; i < count; i++) {
    cells.add(CELL);
  }
  AbstractRpcClient client = createRpcClient(conf);
  TestRpcServer rpcServer = new TestRpcServer();
  try {
    rpcServer.start();
    MethodDescriptor md = SERVICE.getDescriptorForType().findMethodByName("echo");
    EchoRequestProto param = EchoRequestProto.newBuilder().setMessage("hello").build();
    PayloadCarryingRpcController pcrc =
        new PayloadCarryingRpcController(CellUtil.createCellScanner(cells));
    InetSocketAddress address = rpcServer.getListenerAddress();
    if (address == null) {
      throw new IOException("Listener channel is closed");
    }
    Pair<Message, CellScanner> r =
        client.call(pcrc, md, param, md.getOutputType().toProto(), User.getCurrent(), address,
            new MetricsConnection.CallStats());
    int index = 0;
    while (r.getSecond().advance()) {
      assertTrue(CELL.equals(r.getSecond().current()));
      index++;
    }
    assertEquals(count, index);
  } finally {
    client.close();
    rpcServer.stop();
  }
}
 

import org.apache.hadoop.hbase.CellUtil; //导入方法依赖的package包/类
@Override
public CellScanner cellScanner() {
  return CellUtil.createCellScanner(getFamilyCellMap());
}
 

import org.apache.hadoop.hbase.CellUtil; //导入方法依赖的package包/类
public PayloadCarryingRpcController(final List<CellScannable> cellIterables) {
  this.cellScanner = cellIterables == null? null: CellUtil.createCellScanner(cellIterables);
}