How to use

action

method

in

org.apache.hadoop.hbase.client.AsyncRpcRetryingCallerFactory$SingleRequestCallerBuilder

@Test
public void testOperationTimeout() throws IOException, InterruptedException {
 long startNs = System.nanoTime();
 try {
  CONN.callerFactory.single().table(TABLE_NAME).row(ROW).operationTimeout(1, TimeUnit.SECONDS)
   .pause(100, TimeUnit.MILLISECONDS).maxAttempts(Integer.MAX_VALUE)
   .action((controller, loc, stub) -> failedFuture()).call().get();
  fail();
 } catch (ExecutionException e) {
  e.printStackTrace();
  assertThat(e.getCause(), instanceOf(RetriesExhaustedException.class));
 }
 long costNs = System.nanoTime() - startNs;
 assertTrue(costNs >= TimeUnit.SECONDS.toNanos(1));
 assertTrue(costNs < TimeUnit.SECONDS.toNanos(2));
}

@Test
public void testMaxRetries() throws IOException, InterruptedException {
 try {
  CONN.callerFactory.single().table(TABLE_NAME).row(ROW).operationTimeout(1, TimeUnit.DAYS)
   .maxAttempts(3).pause(10, TimeUnit.MILLISECONDS)
   .action((controller, loc, stub) -> failedFuture()).call().get();
  fail();
 } catch (ExecutionException e) {
  assertThat(e.getCause(), instanceOf(RetriesExhaustedException.class));
 }
}

@Override
public void callMethod(MethodDescriptor method, RpcController controller, Message request,
  Message responsePrototype, RpcCallback<Message> done) {
 conn.callerFactory.<Message> single().table(tableName).row(row)
   .locateType(RegionLocateType.CURRENT).rpcTimeout(rpcTimeoutNs, TimeUnit.NANOSECONDS)
   .operationTimeout(operationTimeoutNs, TimeUnit.NANOSECONDS)
   .action((c, l, s) -> rpcCall(method, request, responsePrototype, c, l, s)).call()
   .whenComplete((r, e) -> {
    if (e != null) {
     ((ClientCoprocessorRpcController) controller).setFailed(e);
    }
    done.run(r);
   });
}

@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();
}

@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<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();
}

 @Override
 public CompletableFuture<Boolean> thenMutate(RowMutations mutation) {
  preCheck();
  return RawAsyncTableImpl.this.<Boolean> newCaller(mutation, rpcTimeoutNs)
    .action((controller, loc, stub) -> RawAsyncTableImpl.<Boolean> mutateRow(controller, loc,
     stub, mutation,
     (rn, rm) -> RequestConverter.buildMutateRequest(rn, row, family, qualifier,
      new BinaryComparator(value), CompareType.valueOf(op.name()), timeRange, rm),
     resp -> resp.getExists()))
    .call();
 }
}

@Override
public CompletableFuture<Result> get(Get get) {
 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())))
   .call();
}

@Override
public CompletableFuture<Boolean> thenPut(Put put) {
 preCheck();
 return RawAsyncTableImpl.this.<Boolean> newCaller(row, rpcTimeoutNs)
   .action((controller, loc, stub) -> RawAsyncTableImpl.<Put, Boolean> mutate(controller,
    loc, stub, put,
    (rn, p) -> RequestConverter.buildMutateRequest(rn, row, family, qualifier,
     new BinaryComparator(value), CompareType.valueOf(op.name()), timeRange, p),
    (c, r) -> r.getProcessed()))
   .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<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<Boolean> thenMutate(RowMutations mutation) {
  preCheck();
  return RawAsyncTableImpl.this.<Boolean> newCaller(mutation, rpcTimeoutNs)
   .action((controller, loc, stub) -> RawAsyncTableImpl.<Boolean> mutateRow(controller, loc,
    stub, mutation,
    (rn, rm) -> RequestConverter.buildMutateRequest(rn, row, family, qualifier,
     new BinaryComparator(value), CompareType.valueOf(op.name()), timeRange, rm),
    resp -> resp.getExists()))
   .call();
 }
}

@Override
public CompletableFuture<Boolean> thenDelete(Delete delete) {
 preCheck();
 return RawAsyncTableImpl.this.<Boolean> newCaller(row, rpcTimeoutNs)
  .action((controller, loc, stub) -> RawAsyncTableImpl.<Delete, Boolean> mutate(controller,
   loc, stub, delete,
   (rn, d) -> RequestConverter.buildMutateRequest(rn, row, family, qualifier,
    new BinaryComparator(value), CompareType.valueOf(op.name()), timeRange, d),
   (c, r) -> r.getProcessed()))
  .call();
}

@Override
public CompletableFuture<Boolean> thenPut(Put put) {
 preCheck();
 return RawAsyncTableImpl.this.<Boolean> newCaller(row, rpcTimeoutNs)
  .action((controller, loc, stub) -> RawAsyncTableImpl.<Put, Boolean> mutate(controller, loc,
   stub, put,
   (rn, p) -> RequestConverter.buildMutateRequest(rn, row, family, qualifier,
    new BinaryComparator(value), CompareType.valueOf(op.name()), timeRange, p),
   (c, r) -> r.getProcessed()))
  .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();
}

@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 CompletableFuture<OpenScannerResponse> openScanner(int replicaId) {
 return conn.callerFactory.<OpenScannerResponse> single().table(tableName)
  .row(scan.getStartRow()).replicaId(replicaId).locateType(getLocateType(scan))
  .rpcTimeout(rpcTimeoutNs, TimeUnit.NANOSECONDS)
  .operationTimeout(scanTimeoutNs, TimeUnit.NANOSECONDS).pause(pauseNs, TimeUnit.NANOSECONDS)
  .maxAttempts(maxAttempts).startLogErrorsCnt(startLogErrorsCnt).action(this::callOpenScanner)
  .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();
}

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();
}