@Override public CellScanner cellScanner() { return delegate.cellScanner(); }
private static Result toResult(HBaseRpcController controller, MutateResponse resp) throws IOException { if (!resp.hasResult()) { return null; } return ProtobufUtil.toResult(resp.getResult(), controller.cellScanner()); }
/** * Get the RpcController CellScanner. * If the RpcController is a HBaseRpcController, which it is in all cases except * when we are processing Coprocessor Endpoint, then this method returns a reference to the * CellScanner that the HBaseRpcController is carrying. Do it up here in this Callable * so we don't have to scatter ugly instanceof tests around the codebase. Will return null * if called in a Coproccessor Endpoint context. Should never happen. */ protected CellScanner getRpcControllerCellScanner() { return (getRpcController() != null && getRpcController() instanceof HBaseRpcController)? ((HBaseRpcController)getRpcController()).cellScanner(): null; }
@Override public void run(MultiResponse resp) { if (controller.failed()) { future.completeExceptionally(controller.getFailed()); } else { try { org.apache.hadoop.hbase.client.MultiResponse multiResp = ResponseConverter.getResults(req, resp, controller.cellScanner()); Throwable ex = multiResp.getException(regionName); if (ex != null) { future.completeExceptionally(ex instanceof IOException ? ex : new IOException( "Failed to mutate row: " + Bytes.toStringBinary(mutation.getRow()), ex)); } else { future.complete(respConverter .apply((Result) multiResp.getResults().get(regionName).result.get(0))); } } catch (IOException e) { future.completeExceptionally(e); } } } });
try { onComplete(serverReq.actionsByRegion, tries, sn, ResponseConverter.getResults(req, rowMutationsIndexMap, resp, controller.cellScanner())); } catch (Exception e) { onError(serverReq.actionsByRegion, tries, e, sn);
private CompletableFuture<Result> get(Get get, int replicaId) { return this.<Result> newCaller(get, readRpcTimeoutNs) .action((controller, loc, stub) -> RawAsyncTableImpl .<Get, GetRequest, GetResponse, Result> call(controller, loc, stub, get, RequestConverter::buildGetRequest, (s, c, req, done) -> s.get(c, req, done), (c, resp) -> ProtobufUtil.toResult(resp.getResult(), c.cellScanner()))) .replicaId(replicaId).call(); }
@Override // TODO: Very like the super class implemenation. Can we shrink this down? protected Result rpcCall() throws Exception { if (getRpcController().isCanceled()) return null; if (Thread.interrupted()) { throw new InterruptedIOException(); } byte[] reg = location.getRegionInfo().getRegionName(); ClientProtos.GetRequest request = RequestConverter.buildGetRequest(reg, get); HBaseRpcController hrc = (HBaseRpcController)getRpcController(); hrc.reset(); hrc.setCallTimeout(rpcTimeout); hrc.setPriority(tableName); ClientProtos.GetResponse response = getStub().get(hrc, request); if (response == null) { return null; } return ProtobufUtil.toResult(response.getResult(), hrc.cellScanner()); } }
responseSize); return new Pair<>(result, controller.cellScanner()); } catch (Throwable e) {
int numberOfCompleteRowsBefore = resultCache.numberOfCompleteRows(); try { rawResults = ResponseConverter.getResults(controller.cellScanner(), resp); updateResultsMetrics(scanMetrics, rawResults, isHeartbeatMessage); results = resultCache.addAndGet(
@Test public void testListOfCellScannerables() throws IOException { final int count = 10; List<CellScannable> cells = new ArrayList<>(count); for (int i = 0; i < count; i++) { cells.add(createCell(i)); } HBaseRpcController controller = new HBaseRpcControllerImpl(cells); CellScanner cellScanner = controller.cellScanner(); int index = 0; for (; cellScanner.advance(); index++) { Cell cell = cellScanner.current(); byte[] indexBytes = Bytes.toBytes(index); assertTrue("" + index, Bytes.equals(indexBytes, 0, indexBytes.length, cell.getValueArray(), cell.getValueOffset(), cell.getValueLength())); } assertEquals(count, index); }
@Override public EchoResponseProto echo(RpcController controller, EchoRequestProto request) throws ServiceException { if (controller instanceof HBaseRpcController) { HBaseRpcController pcrc = (HBaseRpcController) 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<>(); try { while (cellScanner.advance()) { list.add(cellScanner.current()); } } catch (IOException e) { throw new ServiceException(e); } } cellScanner = CellUtil.createCellScanner(list); pcrc.setCellScanner(cellScanner); } return EchoResponseProto.newBuilder().setMessage(request.getMessage()).build(); }
/** * Replicate WAL entries on the region server. * @param controller the RPC controller * @param request the request * @throws ServiceException */ @Override @QosPriority(priority=HConstants.REPLICATION_QOS) public ReplicateWALEntryResponse replicateWALEntry(final RpcController controller, final ReplicateWALEntryRequest request) throws ServiceException { try { checkOpen(); if (regionServer.replicationSinkHandler != null) { requestCount.increment(); List<WALEntry> entries = request.getEntryList(); checkShouldRejectReplicationRequest(entries); CellScanner cellScanner = ((HBaseRpcController) controller).cellScanner(); regionServer.getRegionServerCoprocessorHost().preReplicateLogEntries(); regionServer.replicationSinkHandler.replicateLogEntries(entries, cellScanner, request.getReplicationClusterId(), request.getSourceBaseNamespaceDirPath(), request.getSourceHFileArchiveDirPath()); regionServer.getRegionServerCoprocessorHost().postReplicateLogEntries(); return ReplicateWALEntryResponse.newBuilder().build(); } else { throw new ServiceException("Replication services are not initialized yet"); } } catch (IOException ie) { throw new ServiceException(ie); } }
@Test public void testAsyncEcho() throws IOException { Configuration conf = HBaseConfiguration.create(); RpcServer rpcServer = createRpcServer(null, "testRpcServer", Lists.newArrayList(new RpcServer.BlockingServiceAndInterface( SERVICE, null)), new InetSocketAddress("localhost", 0), CONF, new FifoRpcScheduler(CONF, 1)); try (AbstractRpcClient<?> client = createRpcClient(conf)) { rpcServer.start(); Interface stub = newStub(client, rpcServer.getListenerAddress()); int num = 10; List<HBaseRpcController> pcrcList = new ArrayList<>(); List<BlockingRpcCallback<EchoResponseProto>> callbackList = new ArrayList<>(); for (int i = 0; i < num; i++) { HBaseRpcController pcrc = new HBaseRpcControllerImpl(); BlockingRpcCallback<EchoResponseProto> done = new BlockingRpcCallback<>(); stub.echo(pcrc, EchoRequestProto.newBuilder().setMessage("hello-" + i).build(), done); pcrcList.add(pcrc); callbackList.add(done); } for (int i = 0; i < num; i++) { HBaseRpcController pcrc = pcrcList.get(i); assertFalse(pcrc.failed()); assertNull(pcrc.cellScanner()); assertEquals("hello-" + i, callbackList.get(i).get().getMessage()); } } finally { rpcServer.stop(); } }
stub.echo(pcrc, EchoRequestProto.newBuilder().setMessage(message).build()).getMessage()); int index = 0; CellScanner cellScanner = pcrc.cellScanner(); assertNotNull(cellScanner); while (cellScanner.advance()) {
Call call = new Call(nextCallId(), md, param, hrc.cellScanner(), returnType, hrc.getCallTimeout(), hrc.getPriority(), new RpcCallback<Call>() { @Override
assertEquals(3, cells.size()); HBaseRpcController controller = Mockito.mock(HBaseRpcController.class); Mockito.when(controller.cellScanner()).thenReturn(CellUtil.createCellScanner(cells)); HRegionServer rs = TEST_UTIL.getMiniHBaseCluster().getRegionServer( TEST_UTIL.getMiniHBaseCluster()
final ReplicateWALEntryRequest request) throws ServiceException { long before = EnvironmentEdgeManager.currentTime(); CellScanner cells = ((HBaseRpcController) controller).cellScanner(); try { checkOpen();
/** * Ensure we do not HAVE TO HAVE a codec. */ @Test public void testNoCodec() throws IOException, ServiceException { Configuration conf = HBaseConfiguration.create(); RpcServer rpcServer = createRpcServer(null, "testRpcServer", Lists.newArrayList(new RpcServer.BlockingServiceAndInterface( SERVICE, null)), new InetSocketAddress("localhost", 0), CONF, new FifoRpcScheduler(CONF, 1)); try (AbstractRpcClient<?> client = createRpcClientNoCodec(conf)) { rpcServer.start(); BlockingInterface stub = newBlockingStub(client, rpcServer.getListenerAddress()); HBaseRpcController pcrc = new HBaseRpcControllerImpl(); String message = "hello"; assertEquals(message, stub.echo(pcrc, EchoRequestProto.newBuilder().setMessage(message).build()).getMessage()); assertNull(pcrc.cellScanner()); } finally { rpcServer.stop(); } }
CellScanner cellScanner = controller != null ? controller.cellScanner(): null; if (controller != null) { controller.setCellScanner(null);
assertTrue(resp.getMoreResults()); assertTrue(resp.getMoreResultsInRegion()); assertEquals(0, ResponseConverter.getResults(hrc.cellScanner(), resp).length); long scannerId = resp.getScannerId(); int nextCallSeq = 0; assertTrue(resp.getMoreResults()); assertTrue(resp.getMoreResultsInRegion()); Result[] results = ResponseConverter.getResults(hrc.cellScanner(), resp); assertEquals(1, results.length); assertResult(i, results[0]); assertTrue(resp.getMoreResults()); assertTrue(resp.getMoreResultsInRegion()); assertEquals(0, ResponseConverter.getResults(hrc.cellScanner(), resp).length); for (int i = COUNT / 2; i < COUNT; i++) { req = RequestConverter.buildScanRequest(scannerId, 1, false, nextCallSeq++, false, false, -1); assertTrue(resp.getMoreResults()); assertEquals(i != COUNT - 1, resp.getMoreResultsInRegion()); Result[] results = ResponseConverter.getResults(hrc.cellScanner(), resp); assertEquals(1, results.length); assertResult(i, results[0]);