Java ServerRpcController.getFailedOn方法代码示例

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
@Test
public void testEndpoint() throws Exception {
  final ServerName serverName = TEST_UTIL.getHBaseCluster().getRegionServer(0).getServerName();
  final ServerRpcController controller = new ServerRpcController();
  final BlockingRpcCallback<DummyRegionServerEndpointProtos.DummyResponse> rpcCallback =
      new BlockingRpcCallback<DummyRegionServerEndpointProtos.DummyResponse>();
  DummyRegionServerEndpointProtos.DummyService service =
      ProtobufUtil.newServiceStub(DummyRegionServerEndpointProtos.DummyService.class,
          TEST_UTIL.getHBaseAdmin().coprocessorService(serverName));
  service.dummyCall(controller,
      DummyRegionServerEndpointProtos.DummyRequest.getDefaultInstance(), rpcCallback);
  assertEquals(DUMMY_VALUE, rpcCallback.get().getValue());
  if (controller.failedOnException()) {
    throw controller.getFailedOn();
  }
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
public void cleanupBulkLoad(final String bulkToken) throws IOException {
  try {
    CoprocessorRpcChannel channel = table.coprocessorService(HConstants.EMPTY_START_ROW);
    SecureBulkLoadProtos.SecureBulkLoadService instance =
        ProtobufUtil.newServiceStub(SecureBulkLoadProtos.SecureBulkLoadService.class, channel);

    ServerRpcController controller = new ServerRpcController();

    BlockingRpcCallback<SecureBulkLoadProtos.CleanupBulkLoadResponse> rpcCallback =
        new BlockingRpcCallback<SecureBulkLoadProtos.CleanupBulkLoadResponse>();

    SecureBulkLoadProtos.CleanupBulkLoadRequest request =
        SecureBulkLoadProtos.CleanupBulkLoadRequest.newBuilder()
            .setBulkToken(bulkToken).build();

    instance.cleanupBulkLoad(controller,
        request,
        rpcCallback);

    if (controller.failedOnException()) {
      throw controller.getFailedOn();
    }
  } catch (Throwable throwable) {
    throw new IOException(throwable);
  }
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
@Test
public void testEndpoint() throws Exception {
  final ServerName serverName = TEST_UTIL.getHBaseCluster().getRegionServer(0).getServerName();
  final ServerRpcController controller = new ServerRpcController();
  final BlockingRpcCallback<DummyRegionServerEndpointProtos.DummyResponse> rpcCallback =
      new BlockingRpcCallback<DummyRegionServerEndpointProtos.DummyResponse>();
  DummyRegionServerEndpointProtos.DummyService service =
      ProtobufUtil.newServiceStub(DummyRegionServerEndpointProtos.DummyService.class,
        new HBaseAdmin(CONF).coprocessorService(serverName));
  service.dummyCall(controller,
    DummyRegionServerEndpointProtos.DummyRequest.getDefaultInstance(), rpcCallback);
  assertEquals(DUMMY_VALUE, rpcCallback.get().getValue());
  if (controller.failedOnException()) {
    throw controller.getFailedOn();
  }
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
@Test
public void testEndpoint() throws Exception {
  final ServerName serverName = TEST_UTIL.getHBaseCluster().getRegionServer(0).getServerName();
  final ServerRpcController controller = new ServerRpcController();
  final CoprocessorRpcUtils.BlockingRpcCallback<DummyRegionServerEndpointProtos.DummyResponse>
      rpcCallback = new CoprocessorRpcUtils.BlockingRpcCallback<>();
  DummyRegionServerEndpointProtos.DummyService service =
      ProtobufUtil.newServiceStub(DummyRegionServerEndpointProtos.DummyService.class,
        TEST_UTIL.getAdmin().coprocessorService(serverName));
  service.dummyCall(controller,
      DummyRegionServerEndpointProtos.DummyRequest.getDefaultInstance(), rpcCallback);
  assertEquals(DUMMY_VALUE, rpcCallback.get().getValue());
  if (controller.failedOnException()) {
    throw controller.getFailedOn();
  }
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
public void cleanupBulkLoad(final String bulkToken) throws IOException {
  try {
    CoprocessorRpcChannel channel = table.coprocessorService(HConstants.EMPTY_START_ROW);
    SecureBulkLoadProtos.SecureBulkLoadService instance =
        ProtobufUtil.newServiceStub(SecureBulkLoadProtos.SecureBulkLoadService.class, channel);

    ServerRpcController controller = new ServerRpcController();

    CoprocessorRpcUtils.BlockingRpcCallback<CleanupBulkLoadResponse> rpcCallback =
        new CoprocessorRpcUtils.BlockingRpcCallback<>();

    CleanupBulkLoadRequest request =
        CleanupBulkLoadRequest.newBuilder()
            .setBulkToken(bulkToken).build();

    instance.cleanupBulkLoad(controller,
        request,
        rpcCallback);

    if (controller.failedOnException()) {
      throw controller.getFailedOn();
    }
  } catch (Throwable throwable) {
    throw new IOException(throwable);
  }
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
@Override
public CoprocessorServiceResponse execService(final RpcController controller,
    final CoprocessorServiceRequest request) throws ServiceException {
  try {
    requestCount.increment();
    HRegion region = getRegion(request.getRegion());
    // ignore the passed in controller (from the serialized call)
    ServerRpcController execController = new ServerRpcController();
    Message result = region.execService(execController, request.getCall());
    if (execController.getFailedOn() != null) {
      throw execController.getFailedOn();
    }
    CoprocessorServiceResponse.Builder builder =
        CoprocessorServiceResponse.newBuilder();
    builder.setRegion(RequestConverter.buildRegionSpecifier(
        RegionSpecifierType.REGION_NAME, region.getRegionName()));
    builder.setValue(
        builder.getValueBuilder().setName(result.getClass().getName())
            .setValue(result.toByteString()));
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
public String prepareBulkLoad(final TableName tableName) throws IOException {
  try {
    CoprocessorRpcChannel channel = table.coprocessorService(HConstants.EMPTY_START_ROW);
    SecureBulkLoadProtos.SecureBulkLoadService instance =
        ProtobufUtil.newServiceStub(SecureBulkLoadProtos.SecureBulkLoadService.class, channel);

    ServerRpcController controller = new ServerRpcController();

    BlockingRpcCallback<SecureBulkLoadProtos.PrepareBulkLoadResponse> rpcCallback =
        new BlockingRpcCallback<SecureBulkLoadProtos.PrepareBulkLoadResponse>();

    SecureBulkLoadProtos.PrepareBulkLoadRequest request =
        SecureBulkLoadProtos.PrepareBulkLoadRequest.newBuilder()
        .setTableName(ProtobufUtil.toProtoTableName(tableName)).build();

    instance.prepareBulkLoad(controller,
        request,
        rpcCallback);

    SecureBulkLoadProtos.PrepareBulkLoadResponse response = rpcCallback.get();
    if (controller.failedOnException()) {
      throw controller.getFailedOn();
    }

    return response.getBulkToken();
  } catch (Throwable throwable) {
    throw new IOException(throwable);
  }
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
private Message execServiceOnRegion(HRegion region,
                                    final ClientProtos.CoprocessorServiceCall serviceCall) throws IOException {
    // ignore the passed in controller (from the serialized call)
    ServerRpcController execController = new ServerRpcController();
    Message result = region.execService(execController, serviceCall);
    if (execController.getFailedOn() != null) {
        throw execController.getFailedOn();
    }
    return result;
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
private Message execServiceOnRegion(HRegion region,
    final ClientProtos.CoprocessorServiceCall serviceCall) throws IOException {
  // ignore the passed in controller (from the serialized call)
  ServerRpcController execController = new ServerRpcController();
  Message result = region.execService(execController, serviceCall);
  if (execController.getFailedOn() != null) {
    throw execController.getFailedOn();
  }
  return result;
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
public String prepareBulkLoad(final TableName tableName) throws IOException {
  try {
    CoprocessorRpcChannel channel = table.coprocessorService(HConstants.EMPTY_START_ROW);
    SecureBulkLoadProtos.SecureBulkLoadService instance =
        ProtobufUtil.newServiceStub(SecureBulkLoadProtos.SecureBulkLoadService.class, channel);

    ServerRpcController controller = new ServerRpcController();

    CoprocessorRpcUtils.BlockingRpcCallback<PrepareBulkLoadResponse> rpcCallback =
        new CoprocessorRpcUtils.BlockingRpcCallback<>();

    PrepareBulkLoadRequest request =
        PrepareBulkLoadRequest.newBuilder()
        .setTableName(ProtobufUtil.toProtoTableName(tableName)).build();

    instance.prepareBulkLoad(controller, request, rpcCallback);

    PrepareBulkLoadResponse response = rpcCallback.get();
    if (controller.failedOnException()) {
      throw controller.getFailedOn();
    }

    return response.getBulkToken();
  } catch (Throwable throwable) {
    throw new IOException(throwable);
  }
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
public BulkWritesResult invoke(BulkWrites write) throws IOException {
    TableName tableName=tableInfoFactory.getTableInfo(this.tableName);
    CoprocessorRpcChannel channel = channelFactory.newChannel(tableName,write.getRegionKey());

    boolean cacheCheck = false;
    try {
        SpliceMessage.SpliceIndexService service = ProtobufUtil.newServiceStub(SpliceMessage.SpliceIndexService.class, channel);
        SpliceMessage.BulkWriteRequest.Builder builder = SpliceMessage.BulkWriteRequest.newBuilder();
        byte[] requestBytes = compressor.compress(write);
        builder.setBytes(ZeroCopyLiteralByteString.wrap(requestBytes));
        SpliceMessage.BulkWriteRequest bwr = builder.build();

        BlockingRpcCallback<SpliceMessage.BulkWriteResponse> doneCallback =new BlockingRpcCallback<>();
        ServerRpcController controller = new ServerRpcController();
        service.bulkWrite(controller, bwr, doneCallback);
        if (controller.failed()){
            IOException error=controller.getFailedOn();
            clearCacheIfNeeded(error);
            cacheCheck=true;
            if(error!=null)
                throw pef.processRemoteException(error);
            else
                throw pef.fromErrorString(controller.errorText());
        }
        SpliceMessage.BulkWriteResponse bulkWriteResponse = doneCallback.get();
        byte[] bytes = bulkWriteResponse.getBytes().toByteArray();
        if(bytes==null || bytes.length<=0){
            Logger logger=Logger.getLogger(BulkWriteChannelInvoker.class);
            logger.error("zero-length bytes returned with a null error for encodedString: "+write.getBulkWrites().iterator().next().getEncodedStringName());
        }

        return compressor.decompress(bytes,BulkWritesResult.class);
    } catch (Exception e) {
    	if (!cacheCheck) clearCacheIfNeeded(e);
        throw pef.processRemoteException(e);
    }
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
@Override
public ClientProtos.CoprocessorServiceResponse execMasterService(final RpcController controller,
    final ClientProtos.CoprocessorServiceRequest request) throws ServiceException {
  try {
    master.checkInitialized();
    ServerRpcController execController = new ServerRpcController();

    ClientProtos.CoprocessorServiceCall call = request.getCall();
    String serviceName = call.getServiceName();
    String methodName = call.getMethodName();
    if (!master.coprocessorServiceHandlers.containsKey(serviceName)) {
      throw new UnknownProtocolException(null,
        "No registered master coprocessor service found for name "+serviceName);
    }

    Service service = master.coprocessorServiceHandlers.get(serviceName);
    Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
    Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
    if (methodDesc == null) {
      throw new UnknownProtocolException(service.getClass(),
        "Unknown method "+methodName+" called on master service "+serviceName);
    }

    //invoke the method
    Message.Builder builderForType = service.getRequestPrototype(methodDesc).newBuilderForType();
    ProtobufUtil.mergeFrom(builderForType, call.getRequest());
    Message execRequest = builderForType.build();
    final Message.Builder responseBuilder =
        service.getResponsePrototype(methodDesc).newBuilderForType();
    service.callMethod(methodDesc, execController, execRequest, new RpcCallback<Message>() {
      @Override
      public void run(Message message) {
        if (message != null) {
          responseBuilder.mergeFrom(message);
        }
      }
    });
    Message execResult = responseBuilder.build();

    if (execController.getFailedOn() != null) {
      throw execController.getFailedOn();
    }
    ClientProtos.CoprocessorServiceResponse.Builder builder =
      ClientProtos.CoprocessorServiceResponse.newBuilder();
    builder.setRegion(RequestConverter.buildRegionSpecifier(
      RegionSpecifierType.REGION_NAME, HConstants.EMPTY_BYTE_ARRAY));
    builder.setValue(
      builder.getValueBuilder().setName(execResult.getClass().getName())
        .setValue(execResult.toByteString()));
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
public boolean bulkLoadHFiles(final List<Pair<byte[], String>> familyPaths,
                       final Token<?> userToken,
                       final String bulkToken,
                       final byte[] startRow) throws IOException {
  // we never want to send a batch of HFiles to all regions, thus cannot call
  // HTable#coprocessorService methods that take start and end rowkeys; see HBASE-9639
  try {
    CoprocessorRpcChannel channel = table.coprocessorService(startRow);
    SecureBulkLoadProtos.SecureBulkLoadService instance =
        ProtobufUtil.newServiceStub(SecureBulkLoadProtos.SecureBulkLoadService.class, channel);

    SecureBulkLoadProtos.DelegationToken protoDT =
        SecureBulkLoadProtos.DelegationToken.newBuilder().build();
    if(userToken != null) {
      protoDT =
          SecureBulkLoadProtos.DelegationToken.newBuilder()
            .setIdentifier(ByteStringer.wrap(userToken.getIdentifier()))
            .setPassword(ByteStringer.wrap(userToken.getPassword()))
            .setKind(userToken.getKind().toString())
            .setService(userToken.getService().toString()).build();
    }

    List<ClientProtos.BulkLoadHFileRequest.FamilyPath> protoFamilyPaths =
        new ArrayList<ClientProtos.BulkLoadHFileRequest.FamilyPath>();
    for(Pair<byte[], String> el: familyPaths) {
      protoFamilyPaths.add(ClientProtos.BulkLoadHFileRequest.FamilyPath.newBuilder()
        .setFamily(ByteStringer.wrap(el.getFirst()))
        .setPath(el.getSecond()).build());
    }

    SecureBulkLoadProtos.SecureBulkLoadHFilesRequest request =
        SecureBulkLoadProtos.SecureBulkLoadHFilesRequest.newBuilder()
          .setFsToken(protoDT)
          .addAllFamilyPath(protoFamilyPaths)
          .setBulkToken(bulkToken).build();

    ServerRpcController controller = new ServerRpcController();
    BlockingRpcCallback<SecureBulkLoadProtos.SecureBulkLoadHFilesResponse> rpcCallback =
        new BlockingRpcCallback<SecureBulkLoadProtos.SecureBulkLoadHFilesResponse>();
    instance.secureBulkLoadHFiles(controller,
      request,
      rpcCallback);

    SecureBulkLoadProtos.SecureBulkLoadHFilesResponse response = rpcCallback.get();
    if (controller.failedOnException()) {
      throw controller.getFailedOn();
    }
    return response.getLoaded();
  } catch (Throwable throwable) {
    throw new IOException(throwable);
  }
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
@Override
public ClientProtos.CoprocessorServiceResponse execMasterService(final RpcController controller,
    final ClientProtos.CoprocessorServiceRequest request) throws ServiceException {
  try {
    master.checkInitialized();
    ServerRpcController execController = new ServerRpcController();

    ClientProtos.CoprocessorServiceCall call = request.getCall();
    String serviceName = call.getServiceName();
    String methodName = call.getMethodName();
    if (!master.coprocessorServiceHandlers.containsKey(serviceName)) {
      throw new UnknownProtocolException(null,
        "No registered master coprocessor service found for name "+serviceName);
    }

    Service service = master.coprocessorServiceHandlers.get(serviceName);
    Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
    Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
    if (methodDesc == null) {
      throw new UnknownProtocolException(service.getClass(),
        "Unknown method "+methodName+" called on master service "+serviceName);
    }

    //invoke the method
    Message execRequest = service.getRequestPrototype(methodDesc).newBuilderForType()
        .mergeFrom(call.getRequest()).build();
    final Message.Builder responseBuilder =
        service.getResponsePrototype(methodDesc).newBuilderForType();
    service.callMethod(methodDesc, execController, execRequest, new RpcCallback<Message>() {
      @Override
      public void run(Message message) {
        if (message != null) {
          responseBuilder.mergeFrom(message);
        }
      }
    });
    Message execResult = responseBuilder.build();

    if (execController.getFailedOn() != null) {
      throw execController.getFailedOn();
    }
    ClientProtos.CoprocessorServiceResponse.Builder builder =
      ClientProtos.CoprocessorServiceResponse.newBuilder();
    builder.setRegion(RequestConverter.buildRegionSpecifier(
      RegionSpecifierType.REGION_NAME, HConstants.EMPTY_BYTE_ARRAY));
    builder.setValue(
      builder.getValueBuilder().setName(execResult.getClass().getName())
        .setValue(execResult.toByteString()));
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}
 

import org.apache.hadoop.hbase.ipc.ServerRpcController; //导入方法依赖的package包/类
public CoprocessorServiceResponse execRegionServerService(final RpcController controller,
                                                          final CoprocessorServiceRequest serviceRequest) throws ServiceException {
    try {
        ServerRpcController execController = new ServerRpcController();
        CoprocessorServiceCall call = serviceRequest.getCall();
        String serviceName = call.getServiceName();
        String methodName = call.getMethodName();
        if (!coprocessorServiceHandlers.containsKey(serviceName)) {
            throw new UnknownProtocolException(null,
                    "No registered coprocessor service found for name " + serviceName);
        }
        Service service = coprocessorServiceHandlers.get(serviceName);
        Descriptors.ServiceDescriptor serviceDesc = service.getDescriptorForType();
        Descriptors.MethodDescriptor methodDesc = serviceDesc.findMethodByName(methodName);
        if (methodDesc == null) {
            throw new UnknownProtocolException(service.getClass(), "Unknown method " + methodName
                    + " called on service " + serviceName);
        }
        Message request =
                service.getRequestPrototype(methodDesc).newBuilderForType().mergeFrom(call.getRequest())
                        .build();
        final Message.Builder responseBuilder =
                service.getResponsePrototype(methodDesc).newBuilderForType();
        service.callMethod(methodDesc, controller, request, new RpcCallback<Message>() {
            @Override
            public void run(Message message) {
                if (message != null) {
                    responseBuilder.mergeFrom(message);
                }
            }
        });
        Message execResult = responseBuilder.build();
        if (execController.getFailedOn() != null) {
            throw execController.getFailedOn();
        }
        ClientProtos.CoprocessorServiceResponse.Builder builder =
                ClientProtos.CoprocessorServiceResponse.newBuilder();
        builder.setRegion(RequestConverter.buildRegionSpecifier(RegionSpecifierType.REGION_NAME,
                HConstants.EMPTY_BYTE_ARRAY));
        builder.setValue(builder.getValueBuilder().setName(execResult.getClass().getName())
                .setValue(execResult.toByteString()));
        return builder.build();
    } catch (IOException ie) {
        throw new ServiceException(ie);
    }
}