Java 类org.apache.hadoop.hbase.protobuf.RequestConverter 实例源码

/**
 * Sends an OPEN RPC to the specified server to open the specified region.
 * <p>
 * Open should not fail but can if server just crashed.
 * <p>
 * @param server server to open a region
 * @param region region to open
 * @param versionOfOfflineNode that needs to be present in the offline node
 * when RS tries to change the state from OFFLINE to other states.
 * @param favoredNodes
 */
public RegionOpeningState sendRegionOpen(final ServerName server,
    HRegionInfo region, int versionOfOfflineNode, List<ServerName> favoredNodes)
throws IOException {
  AdminService.BlockingInterface admin = getRsAdmin(server);
  if (admin == null) {
    LOG.warn("Attempting to send OPEN RPC to server " + server.toString() +
      " failed because no RPC connection found to this server");
    return RegionOpeningState.FAILED_OPENING;
  }
  OpenRegionRequest request = RequestConverter.buildOpenRegionRequest(server, 
    region, versionOfOfflineNode, favoredNodes, 
    (RecoveryMode.LOG_REPLAY == this.services.getMasterFileSystem().getLogRecoveryMode()));
  try {
    OpenRegionResponse response = admin.openRegion(null, request);
    return ResponseConverter.getRegionOpeningState(response);
  } catch (ServiceException se) {
    throw ProtobufUtil.getRemoteException(se);
  }
}

/**
 * Sends an OPEN RPC to the specified server to open the specified region.
 * <p>
 * Open should not fail but can if server just crashed.
 * <p>
 * @param server server to open a region
 * @param regionOpenInfos info of a list of regions to open
 * @return a list of region opening states
 */
public List<RegionOpeningState> sendRegionOpen(ServerName server,
    List<Triple<HRegionInfo, Integer, List<ServerName>>> regionOpenInfos)
throws IOException {
  AdminService.BlockingInterface admin = getRsAdmin(server);
  if (admin == null) {
    LOG.warn("Attempting to send OPEN RPC to server " + server.toString() +
      " failed because no RPC connection found to this server");
    return null;
  }

  OpenRegionRequest request = RequestConverter.buildOpenRegionRequest(server, regionOpenInfos,
    (RecoveryMode.LOG_REPLAY == this.services.getMasterFileSystem().getLogRecoveryMode()));
  try {
    OpenRegionResponse response = admin.openRegion(null, request);
    return ResponseConverter.getRegionOpeningStateList(response);
  } catch (ServiceException se) {
    throw ProtobufUtil.getRemoteException(se);
  }
}

@Override public RegionStoreSequenceIds getLastSequenceId(byte[] encodedRegionName) {
  try {
    GetLastFlushedSequenceIdRequest req =
        RequestConverter.buildGetLastFlushedSequenceIdRequest(encodedRegionName);
    RegionServerStatusService.BlockingInterface rss = rssStub;
    if (rss == null) { // Try to connect one more time
      createRegionServerStatusStub();
      rss = rssStub;
      if (rss == null) {
        // Still no luck, we tried
        LOG.warn("Unable to connect to the master to check " + "the last flushed sequence id");
        return RegionStoreSequenceIds.newBuilder().setLastFlushedSequenceId(HConstants.NO_SEQNUM)
            .build();
      }
    }
    GetLastFlushedSequenceIdResponse resp = rss.getLastFlushedSequenceId(null, req);
    return RegionStoreSequenceIds.newBuilder()
        .setLastFlushedSequenceId(resp.getLastFlushedSequenceId())
        .addAllStoreSequenceId(resp.getStoreLastFlushedSequenceIdList()).build();
  } catch (ServiceException e) {
    LOG.warn("Unable to connect to the master to check the last flushed sequence id", e);
    return RegionStoreSequenceIds.newBuilder().setLastFlushedSequenceId(HConstants.NO_SEQNUM)
        .build();
  }
}

@Override
public CoprocessorServiceResponse execService(final RpcController controller,
    final CoprocessorServiceRequest request) throws ServiceException {
  try {
    checkOpen();
    requestCount.increment();
    Region region = getRegion(request.getRegion());
    Message result = execServiceOnRegion(region, request.getCall());
    CoprocessorServiceResponse.Builder builder =
      CoprocessorServiceResponse.newBuilder();
    builder.setRegion(RequestConverter.buildRegionSpecifier(
      RegionSpecifierType.REGION_NAME, region.getRegionInfo().getRegionName()));
    builder.setValue(
      builder.getValueBuilder().setName(result.getClass().getName())
        .setValue(result.toByteString()));
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

@Test
public void testFlushedSequenceIdsSentToHMaster()
throws IOException, InterruptedException, ServiceException {
  SortedMap<byte[], Long> allFlushedSequenceIds =
      new TreeMap<byte[], Long>(Bytes.BYTES_COMPARATOR);
  for (int i = 0; i < NUM_RS; ++i) {
    flushAllRegions(i);
  }
  Thread.sleep(10000);
  HMaster master = TEST_UTIL.getMiniHBaseCluster().getMaster();
  for (int i = 0; i < NUM_RS; ++i) {
    for (byte[] regionName : getRegionsByServer(i)) {
      if (allFlushedSequenceIds.containsKey(regionName)) {
        GetLastFlushedSequenceIdRequest req =
          RequestConverter.buildGetLastFlushedSequenceIdRequest(regionName);

        assertEquals((long)allFlushedSequenceIds.get(regionName),
          master.getMasterRpcServices().getLastFlushedSequenceId(
            null, req).getLastFlushedSequenceId());
      }
    }
  }
}

@Test (timeout=180000)
public void testTableDescriptorsEnumeration() throws Exception {
  MiniHBaseCluster cluster = UTIL.getHBaseCluster();

  HMaster master = cluster.getMaster();
  MasterCoprocessorHost host = master.getMasterCoprocessorHost();
  CPMasterObserver cp = (CPMasterObserver)host.findCoprocessor(
      CPMasterObserver.class.getName());
  cp.resetStates();

  GetTableDescriptorsRequest req =
      RequestConverter.buildGetTableDescriptorsRequest((List<TableName>)null);
  master.getMasterRpcServices().getTableDescriptors(null, req);

  assertTrue("Coprocessor should be called on table descriptors request",
    cp.wasGetTableDescriptorsCalled());
}

@Test(timeout = 60000)
public void testCloseByMasterWithoutZNode() throws Exception {

  // Transition in ZK on. This should fail, as there is no znode
  AdminProtos.CloseRegionRequest crr = RequestConverter.buildCloseRegionRequest(
    getRS().getServerName(), regionName, true);
  AdminProtos.CloseRegionResponse responseClose = getRS().rpcServices.closeRegion(null, crr);
  Assert.assertTrue(responseClose.getClosed());

  // now waiting. After a while, the transition should be done
  while (!getRS().getRegionsInTransitionInRS().isEmpty()) {
    Thread.sleep(1);
  }

  // the region is still available, the close got rejected at the end
  Assert.assertTrue("The close should have failed", getRS().getRegion(regionName).isAvailable());
}

@Test(timeout = 60000)
public void testOpenCloseByMasterWithZNode() throws Exception {

  ZKAssign.createNodeClosing(HTU.getZooKeeperWatcher(), hri, getRS().getServerName());

  AdminProtos.CloseRegionRequest crr = RequestConverter.buildCloseRegionRequest(
    getRS().getServerName(), regionName, true);
  AdminProtos.CloseRegionResponse responseClose = getRS().rpcServices.closeRegion(null, crr);
  Assert.assertTrue(responseClose.getClosed());

  checkRegionIsClosed(HTU, getRS(), hri);

  ZKAssign.deleteClosedNode(HTU.getZooKeeperWatcher(), hri.getEncodedName(),
    getRS().getServerName());

  openRegion(HTU, getRS(), hri);
}

@Test
public void testOpenClosingRegion() throws Exception {
  Assert.assertTrue(getRS().getRegion(regionName).isAvailable());

  try {
    // we re-opened meta so some of its data is lost
    ServerName sn = getRS().getServerName();
    MetaTableAccessor.updateRegionLocation(getRS().getConnection(),
      hri, sn, getRS().getRegion(regionName).getOpenSeqNum(), -1);
    // fake region to be closing now, need to clear state afterwards
    getRS().regionsInTransitionInRS.put(hri.getEncodedNameAsBytes(), Boolean.FALSE);
    AdminProtos.OpenRegionRequest orr =
      RequestConverter.buildOpenRegionRequest(sn, hri, 0, null, null);
    getRS().rpcServices.openRegion(null, orr);
    Assert.fail("The closing region should not be opened");
  } catch (ServiceException se) {
    Assert.assertTrue("The region should be already in transition",
      se.getCause() instanceof RegionAlreadyInTransitionException);
  } finally {
    getRS().regionsInTransitionInRS.remove(hri.getEncodedNameAsBytes());
  }
}

static HTableDescriptor getTableDescriptor(final TableName tableName, HConnection connection,
    RpcRetryingCallerFactory rpcCallerFactory, final RpcControllerFactory rpcControllerFactory,
       int operationTimeout) throws TableNotFoundException, IOException {

    if (tableName == null) return null;
    HTableDescriptor htd = executeCallable(new MasterCallable<HTableDescriptor>(connection) {
      @Override
      public HTableDescriptor call(int callTimeout) throws ServiceException {
        PayloadCarryingRpcController controller = rpcControllerFactory.newController();
        controller.setCallTimeout(callTimeout);
        GetTableDescriptorsResponse htds;
        GetTableDescriptorsRequest req =
                RequestConverter.buildGetTableDescriptorsRequest(tableName);
        htds = master.getTableDescriptors(controller, req);

        if (!htds.getTableSchemaList().isEmpty()) {
          return HTableDescriptor.convert(htds.getTableSchemaList().get(0));
        }
        return null;
      }
    }, rpcCallerFactory, operationTimeout);
    if (htd != null) {
      return htd;
    }
    throw new TableNotFoundException(tableName.getNameAsString());
}

/**
 * Deletes the table but does not block and wait for it be completely removed.
 * You can use Future.get(long, TimeUnit) to wait on the operation to complete.
 * It may throw ExecutionException if there was an error while executing the operation
 * or TimeoutException in case the wait timeout was not long enough to allow the
 * operation to complete.
 *
 * @param desc table descriptor for table
 * @param tableName name of table to delete
 * @throws IOException if a remote or network exception occurs
 * @return the result of the async delete. You can use Future.get(long, TimeUnit)
 *    to wait on the operation to complete.
 */
// TODO: This should be called Async but it will break binary compatibility
private Future<Void> deleteTableAsyncV2(final TableName tableName) throws IOException {
  DeleteTableResponse response = executeCallable(
    new MasterCallable<DeleteTableResponse>(getConnection()) {
      @Override
      public DeleteTableResponse call(int callTimeout) throws ServiceException {
        PayloadCarryingRpcController controller = rpcControllerFactory.newController();
        controller.setCallTimeout(callTimeout);
        controller.setPriority(tableName);
        DeleteTableRequest req =
            RequestConverter.buildDeleteTableRequest(tableName, ng.getNonceGroup(),ng.newNonce());
        return master.deleteTable(controller,req);
      }
    });
  return new DeleteTableFuture(this, tableName, response);
}

/**
 * Enable the table but does not block and wait for it be completely enabled.
 * You can use Future.get(long, TimeUnit) to wait on the operation to complete.
 * It may throw ExecutionException if there was an error while executing the operation
 * or TimeoutException in case the wait timeout was not long enough to allow the
 * operation to complete.
 *
 * @param tableName name of table to delete
 * @throws IOException if a remote or network exception occurs
 * @return the result of the async enable. You can use Future.get(long, TimeUnit)
 *    to wait on the operation to complete.
 */
// TODO: This should be called Async but it will break binary compatibility
private Future<Void> enableTableAsyncV2(final TableName tableName) throws IOException {
  TableName.isLegalFullyQualifiedTableName(tableName.getName());
  EnableTableResponse response = executeCallable(
    new MasterCallable<EnableTableResponse>(getConnection()) {
      @Override
      public EnableTableResponse call(int callTimeout) throws ServiceException {
        PayloadCarryingRpcController controller = rpcControllerFactory.newController();
        controller.setCallTimeout(callTimeout);
        controller.setPriority(tableName);

        LOG.info("Started enable of " + tableName);
        EnableTableRequest req =
            RequestConverter.buildEnableTableRequest(tableName, ng.getNonceGroup(),ng.newNonce());
        return master.enableTable(controller,req);
      }
    });
  return new EnableTableFuture(this, tableName, response);
}

/**
 * Disable the table but does not block and wait for it be completely disabled.
 * You can use Future.get(long, TimeUnit) to wait on the operation to complete.
 * It may throw ExecutionException if there was an error while executing the operation
 * or TimeoutException in case the wait timeout was not long enough to allow the
 * operation to complete.
 *
 * @param tableName name of table to delete
 * @throws IOException if a remote or network exception occurs
 * @return the result of the async disable. You can use Future.get(long, TimeUnit)
 *    to wait on the operation to complete.
 */
// TODO: This should be called Async but it will break binary compatibility
private Future<Void> disableTableAsyncV2(final TableName tableName) throws IOException {
  TableName.isLegalFullyQualifiedTableName(tableName.getName());
  DisableTableResponse response = executeCallable(
    new MasterCallable<DisableTableResponse>(getConnection()) {
      @Override
      public DisableTableResponse call(int callTimeout) throws ServiceException {
        PayloadCarryingRpcController controller = rpcControllerFactory.newController();
        controller.setCallTimeout(callTimeout);
        controller.setPriority(tableName);

        LOG.info("Started disable of " + tableName);
        DisableTableRequest req =
            RequestConverter.buildDisableTableRequest(
              tableName, ng.getNonceGroup(), ng.newNonce());
        return master.disableTable(controller, req);
      }
    });
  return new DisableTableFuture(this, tableName, response);
}

/**
 * Get the status of alter command - indicates how many regions have received
 * the updated schema Asynchronous operation.
 *
 * @param tableName TableName instance
 * @return Pair indicating the number of regions updated Pair.getFirst() is the
 *         regions that are yet to be updated Pair.getSecond() is the total number
 *         of regions of the table
 * @throws IOException
 *           if a remote or network exception occurs
 */
@Override
public Pair<Integer, Integer> getAlterStatus(final TableName tableName)
throws IOException {
  return executeCallable(new MasterCallable<Pair<Integer, Integer>>(getConnection()) {
    @Override
    public Pair<Integer, Integer> call(int callTimeout) throws ServiceException {
      PayloadCarryingRpcController controller = rpcControllerFactory.newController();
      controller.setCallTimeout(callTimeout);
      controller.setPriority(tableName);

      GetSchemaAlterStatusRequest req = RequestConverter
          .buildGetSchemaAlterStatusRequest(tableName);
      GetSchemaAlterStatusResponse ret = master.getSchemaAlterStatus(controller, req);
      Pair<Integer, Integer> pair = new Pair<Integer, Integer>(Integer.valueOf(ret
          .getYetToUpdateRegions()), Integer.valueOf(ret.getTotalRegions()));
      return pair;
    }
  });
}

/**
 * Add a column to an existing table.
 * Asynchronous operation.
 *
 * @param tableName name of the table to add column to
 * @param column column descriptor of column to be added
 * @throws IOException if a remote or network exception occurs
 */
@Override
public void addColumn(final TableName tableName, final HColumnDescriptor column)
throws IOException {
  executeCallable(new MasterCallable<Void>(getConnection()) {
    @Override
    public Void call(int callTimeout) throws ServiceException {
      PayloadCarryingRpcController controller = rpcControllerFactory.newController();
      controller.setCallTimeout(callTimeout);
      controller.setPriority(tableName);
      AddColumnRequest req = RequestConverter.buildAddColumnRequest(
        tableName, column, ng.getNonceGroup(), ng.newNonce());
      master.addColumn(controller,req);
      return null;
    }
  });
}

/**
 * Delete a column from a table.
 * Asynchronous operation.
 *
 * @param tableName name of table
 * @param columnName name of column to be deleted
 * @throws IOException if a remote or network exception occurs
 */
@Override
public void deleteColumn(final TableName tableName, final byte [] columnName)
throws IOException {
  executeCallable(new MasterCallable<Void>(getConnection()) {
    @Override
    public Void call(int callTimeout) throws ServiceException {
      PayloadCarryingRpcController controller = rpcControllerFactory.newController();
      controller.setCallTimeout(callTimeout);
      controller.setPriority(tableName);
      DeleteColumnRequest req = RequestConverter.buildDeleteColumnRequest(
        tableName, columnName, ng.getNonceGroup(), ng.newNonce());
      master.deleteColumn(controller, req);
      return null;
    }
  });
}

/**
 * Modify an existing column family on a table.
 * Asynchronous operation.
 *
 * @param tableName name of table
 * @param descriptor new column descriptor to use
 * @throws IOException if a remote or network exception occurs
 */
@Override
public void modifyColumn(final TableName tableName, final HColumnDescriptor descriptor)
throws IOException {
  executeCallable(new MasterCallable<Void>(getConnection()) {
    @Override
    public Void call(int callTimeout) throws ServiceException {
      PayloadCarryingRpcController controller = rpcControllerFactory.newController();
      controller.setCallTimeout(callTimeout);
      controller.setPriority(tableName);
      ModifyColumnRequest req = RequestConverter.buildModifyColumnRequest(
        tableName, descriptor, ng.getNonceGroup(), ng.newNonce());
      master.modifyColumn(controller, req);
      return null;
    }
  });
}

/**
 * @param regionName
 *          Region name to assign.
 * @throws MasterNotRunningException
 * @throws ZooKeeperConnectionException
 * @throws IOException
 */
@Override
public void assign(final byte[] regionName) throws MasterNotRunningException,
    ZooKeeperConnectionException, IOException {
  final byte[] toBeAssigned = getRegionName(regionName);
  executeCallable(new MasterCallable<Void>(getConnection()) {
    @Override
    public Void call(int callTimeout) throws ServiceException {
      PayloadCarryingRpcController controller = rpcControllerFactory.newController();
      controller.setCallTimeout(callTimeout);
      // Hard to know the table name, at least check if meta
      if (isMetaRegion(regionName)) {
        controller.setPriority(TableName.META_TABLE_NAME);
      }

      AssignRegionRequest request =
        RequestConverter.buildAssignRegionRequest(toBeAssigned);
      master.assignRegion(controller,request);
      return null;
    }
  });
}

/**
 * Unassign a region from current hosting regionserver.  Region will then be
 * assigned to a regionserver chosen at random.  Region could be reassigned
 * back to the same server.  Use {@link #move(byte[], byte[])} if you want
 * to control the region movement.
 * @param regionName Region to unassign. Will clear any existing RegionPlan
 * if one found.
 * @param force If true, force unassign (Will remove region from
 * regions-in-transition too if present. If results in double assignment
 * use hbck -fix to resolve. To be used by experts).
 * @throws MasterNotRunningException
 * @throws ZooKeeperConnectionException
 * @throws IOException
 */
@Override
public void unassign(final byte [] regionName, final boolean force)
throws MasterNotRunningException, ZooKeeperConnectionException, IOException {
  final byte[] toBeUnassigned = getRegionName(regionName);
  executeCallable(new MasterCallable<Void>(getConnection()) {
    @Override
    public Void call(int callTimeout) throws ServiceException {
      PayloadCarryingRpcController controller = rpcControllerFactory.newController();
      controller.setCallTimeout(callTimeout);
      // Hard to know the table name, at least check if meta
      if (isMetaRegion(regionName)) {
        controller.setPriority(TableName.META_TABLE_NAME);
      }
      UnassignRegionRequest request =
        RequestConverter.buildUnassignRegionRequest(toBeUnassigned, force);
      master.unassignRegion(controller, request);
      return null;
    }
  });
}

/**
 * Offline specified region from master's in-memory state. It will not attempt to reassign the
 * region as in unassign. This API can be used when a region not served by any region server and
 * still online as per Master's in memory state. If this API is incorrectly used on active region
 * then master will loose track of that region.
 *
 * This is a special method that should be used by experts or hbck.
 *
 * @param regionName
 *          Region to offline.
 * @throws IOException
 */
@Override
public void offline(final byte [] regionName)
throws IOException {
  executeCallable(new MasterCallable<Void>(getConnection()) {
    @Override
    public Void call(int callTimeout) throws ServiceException {
      PayloadCarryingRpcController controller = rpcControllerFactory.newController();
      controller.setCallTimeout(callTimeout);
      // Hard to know the table name, at least check if meta
      if (isMetaRegion(regionName)) {
        controller.setPriority(TableName.META_TABLE_NAME);
      }
      master.offlineRegion(controller, RequestConverter.buildOfflineRegionRequest(regionName));
      return null;
    }
  });
}

/**
 * Turn the load balancer on or off.
 * @param on If true, enable balancer. If false, disable balancer.
 * @param synchronous If true, it waits until current balance() call, if outstanding, to return.
 * @return Previous balancer value
 */
@Override
public boolean setBalancerRunning(final boolean on, final boolean synchronous)
throws IOException {
  return executeCallable(new MasterCallable<Boolean>(getConnection()) {
    @Override
    public Boolean call(int callTimeout) throws ServiceException {
      PayloadCarryingRpcController controller = rpcControllerFactory.newController();
      controller.setCallTimeout(callTimeout);

      SetBalancerRunningRequest req =
          RequestConverter.buildSetBalancerRunningRequest(on, synchronous);
      return master.setBalancerRunning(controller, req).getPrevBalanceValue();
    }
  });
}

/**
 * Modify an existing table, more IRB friendly version.
 * Asynchronous operation.  This means that it may be a while before your
 * schema change is updated across all of the table.
 *
 * @param tableName name of table.
 * @param htd modified description of the table
 * @throws IOException if a remote or network exception occurs
 */
@Override
public void modifyTable(final TableName tableName, final HTableDescriptor htd)
throws IOException {
  if (!tableName.equals(htd.getTableName())) {
    throw new IllegalArgumentException("the specified table name '" + tableName +
      "' doesn't match with the HTD one: " + htd.getTableName());
  }

  executeCallable(new MasterCallable<Void>(getConnection()) {
    @Override
    public Void call(int callTimeout) throws ServiceException {
      PayloadCarryingRpcController controller = rpcControllerFactory.newController();
      controller.setCallTimeout(callTimeout);
      controller.setPriority(tableName);
      ModifyTableRequest request = RequestConverter.buildModifyTableRequest(
        tableName, htd, ng.getNonceGroup(), ng.newNonce());
      master.modifyTable(controller, request);
      return null;
    }
  });
}

/**
 * Stop the designated regionserver
 * @param hostnamePort Hostname and port delimited by a <code>:</code> as in
 * <code>example.org:1234</code>
 * @throws IOException if a remote or network exception occurs
 */
@Override
public synchronized void stopRegionServer(final String hostnamePort)
throws IOException {
  String hostname = Addressing.parseHostname(hostnamePort);
  int port = Addressing.parsePort(hostnamePort);
  AdminService.BlockingInterface admin =
    this.connection.getAdmin(ServerName.valueOf(hostname, port, 0));
  StopServerRequest request = RequestConverter.buildStopServerRequest(
    "Called by admin client " + this.connection.toString());
  PayloadCarryingRpcController controller = rpcControllerFactory.newController();

  controller.setPriority(HConstants.HIGH_QOS);
  try {
    // TODO: this does not do retries, it should. Set priority and timeout in controller
    admin.stopServer(controller, request);
  } catch (ServiceException se) {
    throw ProtobufUtil.getRemoteException(se);
  }
}

/**
 * {@inheritDoc}
 */
@Override
public CompactionState getCompactionStateForRegion(final byte[] regionName)
throws IOException {
  try {
    Pair<HRegionInfo, ServerName> regionServerPair = getRegion(regionName);
    if (regionServerPair == null) {
      throw new IllegalArgumentException("Invalid region: " + Bytes.toStringBinary(regionName));
    }
    if (regionServerPair.getSecond() == null) {
      throw new NoServerForRegionException(Bytes.toStringBinary(regionName));
    }
    ServerName sn = regionServerPair.getSecond();
    AdminService.BlockingInterface admin = this.connection.getAdmin(sn);
    GetRegionInfoRequest request = RequestConverter.buildGetRegionInfoRequest(
      regionServerPair.getFirst().getRegionName(), true);
    PayloadCarryingRpcController controller = rpcControllerFactory.newController();
    // TODO: this does not do retries, it should. Set priority and timeout in controller
    GetRegionInfoResponse response = admin.getRegionInfo(controller, request);
    return response.getCompactionState();
  } catch (ServiceException se) {
    throw ProtobufUtil.getRemoteException(se);
  }
}

@Override
public long getLastMajorCompactionTimestampForRegion(final byte[] regionName) throws IOException {
  return executeCallable(new MasterCallable<Long>(getConnection()) {
    @Override
    public Long call(int callTimeout) throws ServiceException {
      PayloadCarryingRpcController controller = rpcControllerFactory.newController();
      controller.setCallTimeout(callTimeout);
      MajorCompactionTimestampForRegionRequest req =
          MajorCompactionTimestampForRegionRequest
              .newBuilder()
              .setRegion(
                RequestConverter
                    .buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName)).build();
      return master.getLastMajorCompactionTimestampForRegion(controller, req)
          .getCompactionTimestamp();
    }
  });
}

@Override
public Result call(int callTimeout) throws Exception {
  if (controller.isCanceled()) return null;

  if (Thread.interrupted()) {
    throw new InterruptedIOException();
  }

  byte[] reg = location.getRegionInfo().getRegionName();

  ClientProtos.GetRequest request =
      RequestConverter.buildGetRequest(reg, get);
  controller.setCallTimeout(callTimeout);

  try {
    ClientProtos.GetResponse response = getStub().get(controller, request);
    if (response == null) {
      return null;
    }
    return ProtobufUtil.toResult(response.getResult());
  } catch (ServiceException se) {
    throw ProtobufUtil.getRemoteException(se);
  }
}

private void close() {
  if (this.scannerId == -1L) {
    return;
  }
  try {
    incRPCcallsMetrics();
    ScanRequest request =
        RequestConverter.buildScanRequest(this.scannerId, 0, true, this.scanMetrics != null);
    try {
      getStub().scan(null, request);
    } catch (ServiceException se) {
      throw ProtobufUtil.getRemoteException(se);
    }
  } catch (IOException e) {
    LOG.warn("Ignore, probably already closed", e);
  }
  this.scannerId = -1L;
}

protected long openScanner() throws IOException {
  incRPCcallsMetrics();
  ScanRequest request =
    RequestConverter.buildScanRequest(
      getLocation().getRegionInfo().getRegionName(),
      this.scan, 0, false);
  try {
    ScanResponse response = getStub().scan(null, request);
    long id = response.getScannerId();
    if (logScannerActivity) {
      LOG.info("Open scanner=" + id + " for scan=" + scan.toString()
        + " on region " + getLocation().toString());
    }
    return id;
  } catch (ServiceException se) {
    throw ProtobufUtil.getRemoteException(se);
  }
}

/**
 * @deprecated Use {@link Admin#getTableDescriptorsByTableName(List)} instead
 */
@Deprecated
@Override
public HTableDescriptor[] getHTableDescriptorsByTableName(
    List<TableName> tableNames) throws IOException {
  if (tableNames == null || tableNames.isEmpty()) return new HTableDescriptor[0];
  MasterKeepAliveConnection master = getKeepAliveMasterService();
  try {
    GetTableDescriptorsRequest req =
      RequestConverter.buildGetTableDescriptorsRequest(tableNames);
    return ProtobufUtil.getHTableDescriptorArray(master.getTableDescriptors(null, req));
  } catch (ServiceException se) {
    throw ProtobufUtil.getRemoteException(se);
  } finally {
    master.close();
  }
}

/**
 * Connects to the master to get the table descriptor.
 * @param tableName table name
 * @throws IOException if the connection to master fails or if the table
 *  is not found.
 * @deprecated Use {@link Admin#getTableDescriptor(TableName)} instead
 */
@Deprecated
@Override
public HTableDescriptor getHTableDescriptor(final TableName tableName)
throws IOException {
  if (tableName == null) return null;
  MasterKeepAliveConnection master = getKeepAliveMasterService();
  GetTableDescriptorsResponse htds;
  try {
    GetTableDescriptorsRequest req =
      RequestConverter.buildGetTableDescriptorsRequest(tableName);
    htds = master.getTableDescriptors(null, req);
  } catch (ServiceException se) {
    throw ProtobufUtil.getRemoteException(se);
  } finally {
    master.close();
  }
  if (!htds.getTableSchemaList().isEmpty()) {
    return HTableDescriptor.convert(htds.getTableSchemaList().get(0));
  }
  throw new TableNotFoundException(tableName.getNameAsString());
}

/**
* {@inheritDoc}
* @deprecated Use reversed scan instead.
*/
@Override
@Deprecated
public Result getRowOrBefore(final byte[] row, final byte[] family)
    throws IOException {
  RegionServerCallable<Result> callable = new RegionServerCallable<Result>(this.connection,
      tableName, row) {
    @Override
   public Result call(int callTimeout) throws IOException {
      PayloadCarryingRpcController controller = rpcControllerFactory.newController();
      controller.setPriority(tableName);
      controller.setCallTimeout(callTimeout);
      ClientProtos.GetRequest request = RequestConverter.buildGetRowOrBeforeRequest(
          getLocation().getRegionInfo().getRegionName(), row, family);
      try {
        ClientProtos.GetResponse response = getStub().get(controller, request);
        if (!response.hasResult()) return null;
        return ProtobufUtil.toResult(response.getResult());
      } catch (ServiceException se) {
        throw ProtobufUtil.getRemoteException(se);
      }
    }
  };
  return rpcCallerFactory.<Result>newCaller().callWithRetries(callable, this.operationTimeout);
}

/**
 * {@inheritDoc}
 */
@Override
public boolean checkAndPut(final byte [] row,
    final byte [] family, final byte [] qualifier, final byte [] value,
    final Put put)
throws IOException {
  RegionServerCallable<Boolean> callable =
    new RegionServerCallable<Boolean>(connection, getName(), row) {
      @Override
      public Boolean call(int callTimeout) throws IOException {
        PayloadCarryingRpcController controller = rpcControllerFactory.newController();
        controller.setPriority(tableName);
        controller.setCallTimeout(callTimeout);
        try {
          MutateRequest request = RequestConverter.buildMutateRequest(
              getLocation().getRegionInfo().getRegionName(), row, family, qualifier,
              new BinaryComparator(value), CompareType.EQUAL, put);
          MutateResponse response = getStub().mutate(controller, request);
          return Boolean.valueOf(response.getProcessed());
        } catch (ServiceException se) {
          throw ProtobufUtil.getRemoteException(se);
        }
      }
    };
  return rpcCallerFactory.<Boolean> newCaller().callWithRetries(callable, this.operationTimeout);
}

/**
 * {@inheritDoc}
 */
@Override
public boolean checkAndDelete(final byte [] row,
    final byte [] family, final byte [] qualifier, final byte [] value,
    final Delete delete)
throws IOException {
  RegionServerCallable<Boolean> callable =
    new RegionServerCallable<Boolean>(connection, getName(), row) {
      @Override
      public Boolean call(int callTimeout) throws IOException {
        PayloadCarryingRpcController controller = rpcControllerFactory.newController();
        controller.setPriority(tableName);
        controller.setCallTimeout(callTimeout);
        try {
          MutateRequest request = RequestConverter.buildMutateRequest(
            getLocation().getRegionInfo().getRegionName(), row, family, qualifier,
              new BinaryComparator(value), CompareType.EQUAL, delete);
          MutateResponse response = getStub().mutate(controller, request);
          return Boolean.valueOf(response.getProcessed());
        } catch (ServiceException se) {
          throw ProtobufUtil.getRemoteException(se);
        }
      }
    };
  return rpcCallerFactory.<Boolean> newCaller().callWithRetries(callable, this.operationTimeout);
}

/**
 * Sends an OPEN RPC to the specified server to open the specified region.
 * <p>
 * Open should not fail but can if server just crashed.
 * <p>
 * @param server server to open a region
 * @param regionOpenInfos info of a list of regions to open
 * @return a list of region opening states
 */
public List<RegionOpeningState> sendRegionOpen(ServerName server,
    List<Triple<HRegionInfo, Integer, List<ServerName>>> regionOpenInfos)
throws IOException {
  AdminService.BlockingInterface admin = getRsAdmin(server);
  if (admin == null) {
    LOG.warn("Attempting to send OPEN RPC to server " + server.toString() +
      " failed because no RPC connection found to this server");
    return null;
  }

  OpenRegionRequest request = RequestConverter.buildOpenRegionRequest(server, regionOpenInfos,
    (RecoveryMode.LOG_REPLAY == this.services.getMasterFileSystem().getLogRecoveryMode()));
  try {
    OpenRegionResponse response = admin.openRegion(null, request);
    return ResponseConverter.getRegionOpeningStateList(response);
  } catch (ServiceException se) {
    throw ProtobufUtil.getRemoteException(se);
  }
}

@Override
public CoprocessorServiceResponse execService(final RpcController controller,
                                              final CoprocessorServiceRequest request) throws ServiceException {
    try {
        checkOpen();
        requestCount.increment();
        HRegion region = getRegion(request.getRegion());
        Message result = execServiceOnRegion(region, request.getCall());
        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);
    }
}

@Test
public void testFlushedSequenceIdsSentToHMaster()
throws IOException, InterruptedException, ServiceException {
  SortedMap<byte[], Long> allFlushedSequenceIds =
      new TreeMap<byte[], Long>(Bytes.BYTES_COMPARATOR);
  for (int i = 0; i < NUM_RS; ++i) {
    flushAllRegions(i);
  }
  Thread.sleep(10000);
  HMaster master = TEST_UTIL.getMiniHBaseCluster().getMaster();
  for (int i = 0; i < NUM_RS; ++i) {
    for (byte[] regionName : getRegionsByServer(i)) {
      if (allFlushedSequenceIds.containsKey(regionName)) {
        GetLastFlushedSequenceIdRequest req =
          RequestConverter.buildGetLastFlushedSequenceIdRequest(regionName);

        assertEquals((long)allFlushedSequenceIds.get(regionName),
          master.getMasterRpcServices().getLastFlushedSequenceId(
            null, req).getLastFlushedSequenceId());
      }
    }
  }
}

@Test
public void testTableDescriptorsEnumeration() throws Exception {
  MiniHBaseCluster cluster = UTIL.getHBaseCluster();

  HMaster master = cluster.getMaster();
  MasterCoprocessorHost host = master.getMasterCoprocessorHost();
  CPMasterObserver cp = (CPMasterObserver)host.findCoprocessor(
      CPMasterObserver.class.getName());
  cp.resetStates();

  GetTableDescriptorsRequest req =
      RequestConverter.buildGetTableDescriptorsRequest((List<TableName>)null);
  master.getMasterRpcServices().getTableDescriptors(null, req);

  assertTrue("Coprocessor should be called on table descriptors request",
    cp.wasGetTableDescriptorsCalled());
}

@Test(timeout = 60000)
public void testCloseByMasterWithoutZNode() throws Exception {

  // Transition in ZK on. This should fail, as there is no znode
  AdminProtos.CloseRegionRequest crr = RequestConverter.buildCloseRegionRequest(
    getRS().getServerName(), regionName, true);
  AdminProtos.CloseRegionResponse responseClose = getRS().rpcServices.closeRegion(null, crr);
  Assert.assertTrue(responseClose.getClosed());

  // now waiting. After a while, the transition should be done
  while (!getRS().getRegionsInTransitionInRS().isEmpty()) {
    Thread.sleep(1);
  }

  // the region is still available, the close got rejected at the end
  Assert.assertTrue("The close should have failed", getRS().getRegion(regionName).isAvailable());
}

@Test(timeout = 60000)
public void testOpenCloseByMasterWithZNode() throws Exception {

  ZKAssign.createNodeClosing(HTU.getZooKeeperWatcher(), hri, getRS().getServerName());

  AdminProtos.CloseRegionRequest crr = RequestConverter.buildCloseRegionRequest(
    getRS().getServerName(), regionName, true);
  AdminProtos.CloseRegionResponse responseClose = getRS().rpcServices.closeRegion(null, crr);
  Assert.assertTrue(responseClose.getClosed());

  checkRegionIsClosed();

  ZKAssign.deleteClosedNode(HTU.getZooKeeperWatcher(), hri.getEncodedName(),
    getRS().getServerName());

  reopenRegion();
}

@Test
public void testOpenClosingRegion() throws Exception {
  Assert.assertTrue(getRS().getRegion(regionName).isAvailable());

  try {
    // we re-opened meta so some of its data is lost
    ServerName sn = getRS().getServerName();
    MetaTableAccessor.updateRegionLocation(getRS().getConnection(),
      hri, sn, getRS().getRegion(regionName).getOpenSeqNum());
    // fake region to be closing now, need to clear state afterwards
    getRS().regionsInTransitionInRS.put(hri.getEncodedNameAsBytes(), Boolean.FALSE);
    AdminProtos.OpenRegionRequest orr =
      RequestConverter.buildOpenRegionRequest(sn, hri, 0, null, null);
    getRS().rpcServices.openRegion(null, orr);
    Assert.fail("The closing region should not be opened");
  } catch (ServiceException se) {
    Assert.assertTrue("The region should be already in transition",
      se.getCause() instanceof RegionAlreadyInTransitionException);
  } finally {
    getRS().regionsInTransitionInRS.remove(hri.getEncodedNameAsBytes());
  }
}