@Override public AsyncTable<ScanResultConsumer> build() { RawAsyncTableImpl rawTable = new RawAsyncTableImpl(AsyncConnectionImpl.this, RETRY_TIMER, this); return new AsyncTableImpl(AsyncConnectionImpl.this, rawTable, pool); } };
@Override public <T> List<CompletableFuture<T>> batch(List<? extends Row> actions) { return batch(actions, rpcTimeoutNs); }
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 public CompletableFuture<Void> put(Put put) { return this.<Void> newCaller(put, writeRpcTimeoutNs) .action((controller, loc, stub) -> RawAsyncTableImpl.<Put> voidMutate(controller, loc, stub, put, RequestConverter::buildMutateRequest)) .call(); }
@Override public CompletableFuture<Result> append(Append append) { checkHasFamilies(append); return this.<Result> newCaller(append, rpcTimeoutNs) .action((controller, loc, stub) -> this.<Append, Result> noncedMutate(controller, loc, stub, append, RequestConverter::buildMutateRequest, RawAsyncTableImpl::toResult)) .call(); }
private <S, R> void onLocateComplete(Function<RpcChannel, S> stubMaker, ServiceCaller<S, R> callable, CoprocessorCallback<R> callback, List<HRegionLocation> locs, byte[] endKey, boolean endKeyInclusive, AtomicBoolean locateFinished, AtomicInteger unfinishedRequest, HRegionLocation loc, Throwable error) { if (error != null) { callback.onError(error); return; } unfinishedRequest.incrementAndGet(); RegionInfo region = loc.getRegion(); if (locateFinished(region, endKey, endKeyInclusive)) { locateFinished.set(true); } else { addListener( conn.getLocator().getRegionLocation(tableName, region.getEndKey(), RegionLocateType.CURRENT, operationTimeoutNs), (l, e) -> onLocateComplete(stubMaker, callable, callback, locs, endKey, endKeyInclusive, locateFinished, unfinishedRequest, l, e)); } coprocessorService(stubMaker, callable, region, region.getStartKey()).whenComplete((r, e) -> { if (e != null) { callback.onRegionError(region, e); } else { callback.onRegionComplete(region, r); } if (unfinishedRequest.decrementAndGet() == 0 && locateFinished.get()) { callback.onComplete(); } }); }
@Override public CompletableFuture<Void> mutateRow(RowMutations mutation) { return this.<Void> newCaller(mutation, writeRpcTimeoutNs).action((controller, loc, stub) -> RawAsyncTableImpl.<Void> mutateRow(controller, loc, stub, mutation, (rn, rm) -> { RegionAction.Builder regionMutationBuilder = RequestConverter.buildRegionAction(rn, rm); regionMutationBuilder.setAtomic(true); return MultiRequest.newBuilder().addRegionAction(regionMutationBuilder.build()).build(); }, resp -> null)) .call(); }
private static <REQ> CompletableFuture<Void> voidMutate(HBaseRpcController controller, HRegionLocation loc, ClientService.Interface stub, REQ req, Converter<MutateRequest, byte[], REQ> reqConvert) { return mutate(controller, loc, stub, req, reqConvert, (c, resp) -> { return null; }); }
@Override public CompletableFuture<Result> get(Get get) { return timelineConsistentRead(conn.getLocator(), tableName, get, get.getRow(), RegionLocateType.CURRENT, replicaId -> get(get, replicaId), readRpcTimeoutNs, conn.connConf.getPrimaryCallTimeoutNs(), retryTimer); }
private static <REQ, RESP> CompletableFuture<RESP> mutate(HBaseRpcController controller, HRegionLocation loc, ClientService.Interface stub, REQ req, Converter<MutateRequest, byte[], REQ> reqConvert, Converter<RESP, HBaseRpcController, MutateResponse> respConverter) { return call(controller, loc, stub, req, reqConvert, (s, c, r, done) -> s.mutate(c, r, done), respConverter); }
@Override public <S, R> CompletableFuture<R> coprocessorService(Function<RpcChannel, S> stubMaker, ServiceCaller<S, R> callable, byte[] row) { return coprocessorService(stubMaker, callable, null, row); }
private <T> SingleRequestCallerBuilder<T> newCaller(Row row, long rpcTimeoutNs) { return newCaller(row.getRow(), rpcTimeoutNs); }
if (locateFinished(region, endKey, endKeyInclusive)) { locateFinished.set(true); } else { .getRegionLocation(tableName, region.getEndKey(), RegionLocateType.CURRENT, operationTimeoutNs) .whenComplete((l, e) -> onLocateComplete(stubMaker, callable, callback, locs, endKey, endKeyInclusive, locateFinished, unfinishedRequest, l, e)); coprocessorService(stubMaker, callable, region, region.getStartKey()).whenComplete((r, e) -> { if (e != null) { callback.onRegionError(region, e);
@Override public CompletableFuture<Void> delete(Delete delete) { return this.<Void> newCaller(delete, writeRpcTimeoutNs) .action((controller, loc, stub) -> RawAsyncTableImpl.<Delete> voidMutate(controller, loc, stub, delete, RequestConverter::buildMutateRequest)) .call(); }
@Override public CompletableFuture<Result> increment(Increment increment) { checkHasFamilies(increment); return this.<Result> newCaller(increment, rpcTimeoutNs) .action((controller, loc, stub) -> this.<Increment, Result> noncedMutate(controller, loc, stub, increment, RequestConverter::buildMutateRequest, RawAsyncTableImpl::toResult)) .call(); }
@Override public CompletableFuture<Void> mutateRow(RowMutations mutation) { return this.<Void> newCaller(mutation, writeRpcTimeoutNs).action((controller, loc, stub) -> RawAsyncTableImpl.<Void> mutateRow(controller, loc, stub, mutation, (rn, rm) -> { RegionAction.Builder regionMutationBuilder = RequestConverter.buildRegionAction(rn, rm); regionMutationBuilder.setAtomic(true); return MultiRequest.newBuilder().addRegionAction(regionMutationBuilder.build()).build(); }, resp -> null)).call(); }
private <REQ, RESP> CompletableFuture<RESP> noncedMutate(HBaseRpcController controller, HRegionLocation loc, ClientService.Interface stub, REQ req, NoncedConverter<MutateRequest, byte[], REQ> reqConvert, Converter<RESP, HBaseRpcController, MutateResponse> respConverter) { long nonceGroup = conn.getNonceGenerator().getNonceGroup(); long nonce = conn.getNonceGenerator().newNonce(); return mutate(controller, loc, stub, req, (info, src) -> reqConvert.convert(info, src, nonceGroup, nonce), respConverter); }
protected CompletableFuture<Result> rawGet(Get get) { return super.get(get); }
private static <REQ, RESP> CompletableFuture<RESP> mutate(HBaseRpcController controller, HRegionLocation loc, ClientService.Interface stub, REQ req, Converter<MutateRequest, byte[], REQ> reqConvert, Converter<RESP, HBaseRpcController, MutateResponse> respConverter) { return call(controller, loc, stub, req, reqConvert, (s, c, r, done) -> s.mutate(c, r, done), respConverter); }
@Override public <S, R> CompletableFuture<R> coprocessorService(Function<RpcChannel, S> stubMaker, ServiceCaller<S, R> callable, byte[] row) { return coprocessorService(stubMaker, callable, null, row); }