java类com.google.protobuf.ServiceException的实例源码

/**
 * A helper to split a region using admin protocol.
 *
 * @param admin
 * @param hri
 * @param splitPoint
 * @throws IOException
 */
public static void split(final RpcController controller,
    final AdminService.BlockingInterface admin, final HRegionInfo hri, byte[] splitPoint)
        throws IOException {
  SplitRegionRequest request =
    RequestConverter.buildSplitRegionRequest(hri.getRegionName(), splitPoint);
  try {
    admin.splitRegion(controller, request);
  } catch (ServiceException se) {
    throw ProtobufUtil.getRemoteException(se);
  }
}

@Override
@QosPriority(priority=HConstants.ADMIN_QOS)
public GetStoreFileResponse getStoreFile(final RpcController controller,
    final GetStoreFileRequest request) throws ServiceException {
  try {
    checkOpen();
    Region region = getRegion(request.getRegion());
    requestCount.increment();
    Set<byte[]> columnFamilies;
    if (request.getFamilyCount() == 0) {
      columnFamilies = region.getTableDesc().getFamiliesKeys();
    } else {
      columnFamilies = new TreeSet<byte[]>(Bytes.BYTES_RAWCOMPARATOR);
      for (ByteString cf: request.getFamilyList()) {
        columnFamilies.add(cf.toByteArray());
      }
    }
    int nCF = columnFamilies.size();
    List<String>  fileList = region.getStoreFileList(
      columnFamilies.toArray(new byte[nCF][]));
    GetStoreFileResponse.Builder builder = GetStoreFileResponse.newBuilder();
    builder.addAllStoreFile(fileList);
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

@Override
public RenewDelegationTokenResponseProto renewDelegationToken(
    RpcController controller, RenewDelegationTokenRequestProto req)
    throws ServiceException {
  try {
    long result = server.renewDelegationToken(PBHelper
        .convertDelegationToken(req.getToken()));
    return RenewDelegationTokenResponseProto.newBuilder()
        .setNewExpiryTime(result).build();
  } catch (IOException e) {
    throw new ServiceException(e);
  }
}

@Override
public void gracefulFailover() throws IOException, AccessControlException {
  try {
    rpcProxy.gracefulFailover(NULL_CONTROLLER,
        GracefulFailoverRequestProto.getDefaultInstance());
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}

@Override
public BalanceResponse balance(RpcController controller,
    BalanceRequest request) throws ServiceException {
  try {
    return BalanceResponse.newBuilder().setBalancerRan(master.balance()).build();
  } catch (IOException ex) {
    throw new ServiceException(ex);
  }
}

@Override
public GetDatanodeReportResponseProto getDatanodeReport(
    RpcController controller, GetDatanodeReportRequestProto req)
    throws ServiceException {
  try {
    List<? extends DatanodeInfoProto> result = PBHelper.convert(server
        .getDatanodeReport(PBHelper.convert(req.getType())));
    return GetDatanodeReportResponseProto.newBuilder()
        .addAllDi(result).build();
  } catch (IOException e) {
    throw new ServiceException(e);
  }
}

private void flush(final ServerName sn, final HRegionInfo hri)
throws IOException {
  PayloadCarryingRpcController controller = rpcControllerFactory.newController();
  AdminService.BlockingInterface admin = this.connection.getAdmin(sn);
  FlushRegionRequest request =
    RequestConverter.buildFlushRegionRequest(hri.getRegionName());
  try {
    admin.flushRegion(controller, request);
  } catch (ServiceException se) {
    throw ProtobufUtil.getRemoteException(se);
  }
}

@Override
public void removeAcl(String src) throws IOException {
  RemoveAclRequestProto req = RemoveAclRequestProto.newBuilder()
      .setSrc(src).build();
  try {
    rpcProxy.removeAcl(null, req);
  } catch (ServiceException e) {
    throw ProtobufHelper.getRemoteException(e);
  }
}

private void flushAllRegions(int rsId)
throws ServiceException, IOException {
  HRegionServer hrs = getRegionServer(rsId);
  for (byte[] regionName : getRegionsByServer(rsId)) {
    FlushRegionRequest request =
      RequestConverter.buildFlushRegionRequest(regionName);
    hrs.getRSRpcServices().flushRegion(null, request);
  }
}

@Override
public void run() {
  Integer[] indata = new Integer[datasize];
  Arrays.fill(indata, 123);
  TestProtos.ExchangeRequestProto exchangeRequest =
      TestProtos.ExchangeRequestProto.newBuilder().addAllValues(
          Arrays.asList(indata)).build();
  Integer[] outdata = null;
  TestProtos.ExchangeResponseProto exchangeResponse;

  TestProtos.AddRequestProto addRequest =
      TestProtos.AddRequestProto.newBuilder().setParam1(1)
          .setParam2(2).build();
  TestProtos.AddResponseProto addResponse;

  int val = 0;
  try {
    exchangeResponse = proxy.exchange(null, exchangeRequest);
    outdata = new Integer[exchangeResponse.getValuesCount()];
    outdata = exchangeResponse.getValuesList().toArray(outdata);
    addResponse = proxy.add(null, addRequest);
    val = addResponse.getResult();
  } catch (ServiceException e) {
    assertTrue("Exception from RPC exchange() "  + e, false);
  }
  assertEquals(indata.length, outdata.length);
  assertEquals(3, val);
  for (int i = 0; i < outdata.length; i++) {
    assertEquals(outdata[i].intValue(), i);
  }
}