*

* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* Implements the regionserver RPC services.

*/

    AdminService.BlockingInterface, ClientService.BlockingInterface, PriorityFunction {

  protected static final Log LOG = LogFactory.getLog(RSRpcServices.class);

  /** RPC scheduler to use for the region server. */

  public static final String REGION_SERVER_RPC_SCHEDULER_FACTORY_CLASS =

    "hbase.region.server.rpc.scheduler.factory.class";

  // Request counter. (Includes requests that are not serviced by regions.)

  final Counter requestCount = new Counter();

  // Server to handle client requests.

  final RpcServerInterface rpcServer;

  final InetSocketAddress isa;

  private final HRegionServer regionServer;

  private final long maxScannerResultSize;

  // The reference to the priority extraction function

  private final PriorityFunction priority;

  private final AtomicLong scannerIdGen = new AtomicLong(0L);

  private final ConcurrentHashMap<String, RegionScannerHolder> scanners =

    new ConcurrentHashMap<String, RegionScannerHolder>();

  /**

   * The lease timeout period for client scanners (milliseconds).

   */

  private final int scannerLeaseTimeoutPeriod;

  /**

   * Holder class which holds the RegionScanner and nextCallSeq together.

   */

  private static class RegionScannerHolder {

    private RegionScanner s;

    private long nextCallSeq = 0L;

    private HRegion r;

    public RegionScannerHolder(RegionScanner s, HRegion r) {

      this.s = s;

      this.r = r;

    }

  }

   * Instantiated as a scanner lease. If the lease times out, the scanner is

   * closed

   */

  private class ScannerListener implements LeaseListener {

    private final String scannerName;

    ScannerListener(final String n) {

      this.scannerName = n;

    }

    @Override

    public void leaseExpired() {

      RegionScannerHolder rsh = scanners.remove(this.scannerName);

      if (rsh != null) {

        RegionScanner s = rsh.s;

        LOG.info("Scanner " + this.scannerName + " lease expired on region "

          + s.getRegionInfo().getRegionNameAsString());

        try {

          HRegion region = regionServer.getRegion(s.getRegionInfo().getRegionName());

          if (region != null && region.getCoprocessorHost() != null) {

            region.getCoprocessorHost().preScannerClose(s);

          }

          s.close();

          if (region != null && region.getCoprocessorHost() != null) {

            region.getCoprocessorHost().postScannerClose(s);

          }

        } catch (IOException e) {

          LOG.error("Closing scanner for "

            + s.getRegionInfo().getRegionNameAsString(), e);

        }

      } else {

        LOG.warn("Scanner " + this.scannerName + " lease expired, but no related" +

          " scanner found, hence no chance to close that related scanner!");

      }

    }

  }

  private static ResultOrException getResultOrException(

      final ClientProtos.Result r, final int index) {

    return getResultOrException(ResponseConverter.buildActionResult(r), index);

  }

  private static ResultOrException getResultOrException(final Exception e, final int index) {

    return getResultOrException(ResponseConverter.buildActionResult(e), index);

  }

  private static ResultOrException getResultOrException(

      final ResultOrException.Builder builder, final int index) {

    return builder.setIndex(index).build();

  }

  /**

   * Starts the nonce operation for a mutation, if needed.

   * @param mutation Mutation.

   * @param nonceGroup Nonce group from the request.

   * @returns Nonce used (can be NO_NONCE).

   */

  private long startNonceOperation(final MutationProto mutation, long nonceGroup)

      throws IOException, OperationConflictException {

    if (regionServer.nonceManager == null || !mutation.hasNonce()) return HConstants.NO_NONCE;

    boolean canProceed = false;

    try {

      canProceed = regionServer.nonceManager.startOperation(

        nonceGroup, mutation.getNonce(), regionServer);

    } catch (InterruptedException ex) {

      throw new InterruptedIOException("Nonce start operation interrupted");

    }

    if (!canProceed) {

      // TODO: instead, we could convert append/increment to get w/mvcc

      String message = "The operation with nonce {" + nonceGroup + ", " + mutation.getNonce()

        + "} on row [" + Bytes.toString(mutation.getRow().toByteArray())

        + "] may have already completed";

      throw new OperationConflictException(message);

    }

    return mutation.getNonce();

  }

  /**

   * Ends nonce operation for a mutation, if needed.

   * @param mutation Mutation.

   * @param nonceGroup Nonce group from the request. Always 0 in initial implementation.

   * @param success Whether the operation for this nonce has succeeded.

   */

  private void endNonceOperation(final MutationProto mutation,

      long nonceGroup, boolean success) {

    if (regionServer.nonceManager != null && mutation.hasNonce()) {

      regionServer.nonceManager.endOperation(nonceGroup, mutation.getNonce(), success);

    }

  }

  /**

   * @return True if current call supports cellblocks

   */

  private boolean isClientCellBlockSupport() {

    RpcCallContext context = RpcServer.getCurrentCall();

    return context != null && context.isClientCellBlockSupport();

  }

  private void addResult(final MutateResponse.Builder builder,

      final Result result, final PayloadCarryingRpcController rpcc) {

    if (result == null) return;

    if (isClientCellBlockSupport()) {

      builder.setResult(ProtobufUtil.toResultNoData(result));

      rpcc.setCellScanner(result.cellScanner());

    } else {

      ClientProtos.Result pbr = ProtobufUtil.toResult(result);

      builder.setResult(pbr);

    }

  }

  private void addResults(final ScanResponse.Builder builder, final List<Result> results,

      final RpcController controller, boolean isDefaultRegion) {

    builder.setStale(!isDefaultRegion);

    if (results == null || results.isEmpty()) return;

    if (isClientCellBlockSupport()) {

      for (Result res : results) {

        builder.addCellsPerResult(res.size());

      }

      ((PayloadCarryingRpcController)controller).

        setCellScanner(CellUtil.createCellScanner(results));

    } else {

      for (Result res: results) {

        ClientProtos.Result pbr = ProtobufUtil.toResult(res);

        builder.addResults(pbr);

      }

    }

  }

  /**

   * Mutate a list of rows atomically.

   *

   * @param region

   * @param actions

   * @param cellScanner if non-null, the mutation data -- the Cell content.

   * @throws IOException

   */

  private void mutateRows(final HRegion region, final List<ClientProtos.Action> actions,

      final CellScanner cellScanner) throws IOException {

    if (!region.getRegionInfo().isMetaTable()) {

      regionServer.cacheFlusher.reclaimMemStoreMemory();

    }

    RowMutations rm = null;

    for (ClientProtos.Action action: actions) {

      if (action.hasGet()) {

        throw new DoNotRetryIOException("Atomic put and/or delete only, not a Get=" +

          action.getGet());

      }

      MutationType type = action.getMutation().getMutateType();

      if (rm == null) {

        rm = new RowMutations(action.getMutation().getRow().toByteArray());

      }

      switch (type) {

      case PUT:

        rm.add(ProtobufUtil.toPut(action.getMutation(), cellScanner));

        break;

      case DELETE:

        rm.add(ProtobufUtil.toDelete(action.getMutation(), cellScanner));

        break;

      default:

          throw new DoNotRetryIOException("Atomic put and/or delete only, not " + type.name());

      }

    }

    region.mutateRow(rm);

  }

  /**

   * Execute an append mutation.

   *

   * @param region

   * @param m

   * @param cellScanner

   * @return result to return to client if default operation should be

   * bypassed as indicated by RegionObserver, null otherwise

   * @throws IOException

   */

  private Result append(final HRegion region, final MutationProto m,

      final CellScanner cellScanner, long nonceGroup) throws IOException {

    long before = EnvironmentEdgeManager.currentTime();

    Append append = ProtobufUtil.toAppend(m, cellScanner);

    Result r = null;

    if (region.getCoprocessorHost() != null) {

      r = region.getCoprocessorHost().preAppend(append);

    }

    if (r == null) {

      long nonce = startNonceOperation(m, nonceGroup);

      boolean success = false;

      try {

        r = region.append(append, nonceGroup, nonce);

        success = true;

      } finally {

        endNonceOperation(m, nonceGroup, success);

      }

      if (region.getCoprocessorHost() != null) {

        region.getCoprocessorHost().postAppend(append, r);

      }

    }

    if (regionServer.metricsRegionServer != null) {

      regionServer.metricsRegionServer.updateAppend(

        EnvironmentEdgeManager.currentTime() - before);

    }

    return r;

  }

  /**

   * Execute an increment mutation.

   *

   * @param region

   * @param mutation

   * @return the Result

   * @throws IOException

   */

  private Result increment(final HRegion region, final MutationProto mutation,

      final CellScanner cells, long nonceGroup) throws IOException {

    long before = EnvironmentEdgeManager.currentTime();

    Increment increment = ProtobufUtil.toIncrement(mutation, cells);

    Result r = null;

    if (region.getCoprocessorHost() != null) {

      r = region.getCoprocessorHost().preIncrement(increment);

    }

    if (r == null) {

      long nonce = startNonceOperation(mutation, nonceGroup);

      boolean success = false;

      try {

        r = region.increment(increment, nonceGroup, nonce);

        success = true;

      } finally {

        endNonceOperation(mutation, nonceGroup, success);

      }

      if (region.getCoprocessorHost() != null) {

        r = region.getCoprocessorHost().postIncrement(increment, r);

      }

    }

    if (regionServer.metricsRegionServer != null) {

      regionServer.metricsRegionServer.updateIncrement(

        EnvironmentEdgeManager.currentTime() - before);

    }

    return r;

  }

  /**

   * Run through the regionMutation <code>rm</code> and per Mutation, do the work, and then when

   * done, add an instance of a {@link ResultOrException} that corresponds to each Mutation.

   * @param region

   * @param actions

   * @param cellScanner

   * @param builder

   * @param cellsToReturn  Could be null. May be allocated in this method.  This is what this

   * method returns as a 'result'.

   * @return Return the <code>cellScanner</code> passed

   */

  private List<CellScannable> doNonAtomicRegionMutation(final HRegion region,

      final RegionAction actions, final CellScanner cellScanner,

      final RegionActionResult.Builder builder, List<CellScannable> cellsToReturn, long nonceGroup) {

    // Gather up CONTIGUOUS Puts and Deletes in this mutations List.  Idea is that rather than do

    // one at a time, we instead pass them in batch.  Be aware that the corresponding

    // ResultOrException instance that matches each Put or Delete is then added down in the

    // doBatchOp call.  We should be staying aligned though the Put and Delete are deferred/batched

    List<ClientProtos.Action> mutations = null;

    for (ClientProtos.Action action: actions.getActionList()) {

      ClientProtos.ResultOrException.Builder resultOrExceptionBuilder = null;

      try {

        Result r = null;

        if (action.hasGet()) {

          Get get = ProtobufUtil.toGet(action.getGet());

          r = region.get(get);

        } else if (action.hasServiceCall()) {

          resultOrExceptionBuilder = ResultOrException.newBuilder();

          try {

            Message result = execServiceOnRegion(region, action.getServiceCall());

            ClientProtos.CoprocessorServiceResult.Builder serviceResultBuilder =

                ClientProtos.CoprocessorServiceResult.newBuilder();

            resultOrExceptionBuilder.setServiceResult(

                serviceResultBuilder.setValue(

                  serviceResultBuilder.getValueBuilder()

                    .setName(result.getClass().getName())

                    .setValue(result.toByteString())));

          } catch (IOException ioe) {

            resultOrExceptionBuilder.setException(ResponseConverter.buildException(ioe));

          }

        } else if (action.hasMutation()) {

          MutationType type = action.getMutation().getMutateType();

          if (type != MutationType.PUT && type != MutationType.DELETE && mutations != null &&

              !mutations.isEmpty()) {

            // Flush out any Puts or Deletes already collected.

            doBatchOp(builder, region, mutations, cellScanner);

            mutations.clear();

          }

          switch (type) {

          case APPEND:

            r = append(region, action.getMutation(), cellScanner, nonceGroup);

            break;

          case INCREMENT:

            r = increment(region, action.getMutation(), cellScanner,  nonceGroup);

            break;

          case PUT:

          case DELETE:

            // Collect the individual mutations and apply in a batch

            if (mutations == null) {

              mutations = new ArrayList<ClientProtos.Action>(actions.getActionCount());

            }

            mutations.add(action);

            break;

          default:

            throw new DoNotRetryIOException("Unsupported mutate type: " + type.name());

          }

        } else {

          throw new HBaseIOException("Unexpected Action type");

        }

        if (r != null) {

          ClientProtos.Result pbResult = null;

          if (isClientCellBlockSupport()) {

            pbResult = ProtobufUtil.toResultNoData(r);

            //  Hard to guess the size here.  Just make a rough guess.

            if (cellsToReturn == null) cellsToReturn = new ArrayList<CellScannable>();

            cellsToReturn.add(r);

          } else {

            pbResult = ProtobufUtil.toResult(r);

          }

          resultOrExceptionBuilder =

            ClientProtos.ResultOrException.newBuilder().setResult(pbResult);

        }

        // Could get to here and there was no result and no exception.  Presumes we added

        // a Put or Delete to the collecting Mutations List for adding later.  In this

        // case the corresponding ResultOrException instance for the Put or Delete will be added

        // down in the doBatchOp method call rather than up here.

      } catch (IOException ie) {

        resultOrExceptionBuilder = ResultOrException.newBuilder().

          setException(ResponseConverter.buildException(ie));

      }

      if (resultOrExceptionBuilder != null) {

        // Propagate index.

        resultOrExceptionBuilder.setIndex(action.getIndex());

        builder.addResultOrException(resultOrExceptionBuilder.build());

      }

    }

    // Finish up any outstanding mutations

    if (mutations != null && !mutations.isEmpty()) {

      doBatchOp(builder, region, mutations, cellScanner);

    }

    return cellsToReturn;

  }

  /**

   * Execute a list of Put/Delete mutations.

   *

   * @param builder

   * @param region

   * @param mutations

   */

  private void doBatchOp(final RegionActionResult.Builder builder, final HRegion region,

      final List<ClientProtos.Action> mutations, final CellScanner cells) {

    Mutation[] mArray = new Mutation[mutations.size()];

    long before = EnvironmentEdgeManager.currentTime();

    boolean batchContainsPuts = false, batchContainsDelete = false;

    try {

      int i = 0;

      for (ClientProtos.Action action: mutations) {

        MutationProto m = action.getMutation();

        Mutation mutation;

        if (m.getMutateType() == MutationType.PUT) {

          mutation = ProtobufUtil.toPut(m, cells);

          batchContainsPuts = true;

        } else {

          mutation = ProtobufUtil.toDelete(m, cells);

          batchContainsDelete = true;

        }

        mArray[i++] = mutation;

      }

      if (!region.getRegionInfo().isMetaTable()) {

        regionServer.cacheFlusher.reclaimMemStoreMemory();

      }

      OperationStatus codes[] = region.batchMutate(mArray);

      for (i = 0; i < codes.length; i++) {

        int index = mutations.get(i).getIndex();

        Exception e = null;

        switch (codes[i].getOperationStatusCode()) {

          case BAD_FAMILY:

            e = new NoSuchColumnFamilyException(codes[i].getExceptionMsg());

            builder.addResultOrException(getResultOrException(e, index));

            break;

          case SANITY_CHECK_FAILURE:

            e = new FailedSanityCheckException(codes[i].getExceptionMsg());

            builder.addResultOrException(getResultOrException(e, index));

            break;

          default:

            e = new DoNotRetryIOException(codes[i].getExceptionMsg());

            builder.addResultOrException(getResultOrException(e, index));

            break;

          case SUCCESS:

            builder.addResultOrException(getResultOrException(

              ClientProtos.Result.getDefaultInstance(), index));

            break;

        }

      }

    } catch (IOException ie) {

      for (int i = 0; i < mutations.size(); i++) {

        builder.addResultOrException(getResultOrException(ie, mutations.get(i).getIndex()));

      }

    }

    if (regionServer.metricsRegionServer != null) {

      long after = EnvironmentEdgeManager.currentTime();

      if (batchContainsPuts) {

        regionServer.metricsRegionServer.updatePut(after - before);

      }

      if (batchContainsDelete) {

        regionServer.metricsRegionServer.updateDelete(after - before);

      }

    }

  }

  /**

   * Execute a list of Put/Delete mutations. The function returns OperationStatus instead of

   * constructing MultiResponse to save a possible loop if caller doesn't need MultiResponse.

   * @param region

   * @param mutations

   * @param replaySeqId

   * @return an array of OperationStatus which internally contains the OperationStatusCode and the

   *         exceptionMessage if any

   * @throws IOException

   */

  private OperationStatus [] doReplayBatchOp(final HRegion region,

      final List<HLogSplitter.MutationReplay> mutations, long replaySeqId) throws IOException {

    long before = EnvironmentEdgeManager.currentTime();

    boolean batchContainsPuts = false, batchContainsDelete = false;

    try {

      for (Iterator<HLogSplitter.MutationReplay> it = mutations.iterator(); it.hasNext();) {

        HLogSplitter.MutationReplay m = it.next();

        if (m.type == MutationType.PUT) {

          batchContainsPuts = true;

        } else {

          batchContainsDelete = true;

        }

        NavigableMap<byte[], List<Cell>> map = m.mutation.getFamilyCellMap();

        List<Cell> metaCells = map.get(WALEdit.METAFAMILY);

        if (metaCells != null && !metaCells.isEmpty()) {

          for (Cell metaCell : metaCells) {

            CompactionDescriptor compactionDesc = WALEdit.getCompaction(metaCell);

            if (compactionDesc != null) {

              region.completeCompactionMarker(compactionDesc);

            }

          }

          it.remove();

        }

      }

      requestCount.add(mutations.size());

      if (!region.getRegionInfo().isMetaTable()) {

        regionServer.cacheFlusher.reclaimMemStoreMemory();

      }

      return region.batchReplay(mutations.toArray(

        new HLogSplitter.MutationReplay[mutations.size()]), replaySeqId);

    } finally {

      if (regionServer.metricsRegionServer != null) {

        long after = EnvironmentEdgeManager.currentTime();

          if (batchContainsPuts) {

          regionServer.metricsRegionServer.updatePut(after - before);

        }

        if (batchContainsDelete) {

          regionServer.metricsRegionServer.updateDelete(after - before);

        }

      }

    }

  }

  private void closeAllScanners() {

    // Close any outstanding scanners. Means they'll get an UnknownScanner

    // exception next time they come in.

    for (Map.Entry<String, RegionScannerHolder> e : scanners.entrySet()) {

      try {

        e.getValue().s.close();

      } catch (IOException ioe) {

        LOG.warn("Closing scanner " + e.getKey(), ioe);

      }

    }

  }

  public RSRpcServices(HRegionServer rs) throws IOException {

    regionServer = rs;

    RpcSchedulerFactory rpcSchedulerFactory;

    try {

      Class<?> rpcSchedulerFactoryClass = rs.conf.getClass(

          REGION_SERVER_RPC_SCHEDULER_FACTORY_CLASS,

          SimpleRpcSchedulerFactory.class);

      rpcSchedulerFactory = ((RpcSchedulerFactory) rpcSchedulerFactoryClass.newInstance());

    } catch (InstantiationException e) {

      throw new IllegalArgumentException(e);

    } catch (IllegalAccessException e) {

      throw new IllegalArgumentException(e);

    }

    // Server to handle client requests.

    String hostname = rs.conf.get("hbase.regionserver.ipc.address",

      Strings.domainNamePointerToHostName(DNS.getDefaultHost(

        rs.conf.get("hbase.regionserver.dns.interface", "default"),

        rs.conf.get("hbase.regionserver.dns.nameserver", "default"))));

    int port = rs.conf.getInt(HConstants.REGIONSERVER_PORT,

      HConstants.DEFAULT_REGIONSERVER_PORT);

    // Creation of a HSA will force a resolve.

    InetSocketAddress initialIsa = new InetSocketAddress(hostname, port);

    if (initialIsa.getAddress() == null) {

      throw new IllegalArgumentException("Failed resolve of " + initialIsa);

    }

    priority = new AnnotationReadingPriorityFunction(this);

    String name = rs.getProcessName() + "/" + initialIsa.toString();

    // Set how many times to retry talking to another server over HConnection.

    ConnectionUtils.setServerSideHConnectionRetriesConfig(rs.conf, name, LOG);

    rpcServer = new RpcServer(rs, name, getServices(),

      initialIsa, // BindAddress is IP we got for this server.

      rs.conf,

      rpcSchedulerFactory.create(rs.conf, this));

    scannerLeaseTimeoutPeriod = rs.conf.getInt(

      HConstants.HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD,

      HConstants.DEFAULT_HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD);

    maxScannerResultSize = rs.conf.getLong(

      HConstants.HBASE_CLIENT_SCANNER_MAX_RESULT_SIZE_KEY,

      HConstants.DEFAULT_HBASE_CLIENT_SCANNER_MAX_RESULT_SIZE);

    // Set our address.

    isa = rpcServer.getListenerAddress();

    rpcServer.setErrorHandler(this);

    rs.setName(name);

  }

  RegionScanner getScanner(long scannerId) {

    String scannerIdString = Long.toString(scannerId);

    RegionScannerHolder scannerHolder = scanners.get(scannerIdString);

    if (scannerHolder != null) {

      return scannerHolder.s;

    }

    return null;

  }

  /**

   * Get the vtime associated with the scanner.

   * Currently the vtime is the number of "next" calls.

   */

  long getScannerVirtualTime(long scannerId) {

    String scannerIdString = Long.toString(scannerId);

    RegionScannerHolder scannerHolder = scanners.get(scannerIdString);

    if (scannerHolder != null) {

      return scannerHolder.nextCallSeq;

    }

    return 0L;

  }

  long addScanner(RegionScanner s, HRegion r) throws LeaseStillHeldException {

    long scannerId = this.scannerIdGen.incrementAndGet();

    String scannerName = String.valueOf(scannerId);

    RegionScannerHolder existing =

      scanners.putIfAbsent(scannerName, new RegionScannerHolder(s, r));

    assert existing == null : "scannerId must be unique within regionserver's whole lifecycle!";

    regionServer.leases.createLease(scannerName, this.scannerLeaseTimeoutPeriod,

        new ScannerListener(scannerName));

    return scannerId;

  }

  /**

   * Find the HRegion based on a region specifier

   *

   * @param regionSpecifier the region specifier

   * @return the corresponding region

   * @throws IOException if the specifier is not null,

   *    but failed to find the region

   */

  HRegion getRegion(

      final RegionSpecifier regionSpecifier) throws IOException {

    return regionServer.getRegionByEncodedName(regionSpecifier.getValue().toByteArray(),

        ProtobufUtil.getRegionEncodedName(regionSpecifier));

  }

  PriorityFunction getPriority() {

    return priority;

  }

  Configuration getConfiguration() {

    return regionServer.getConfiguration();

  }

  void start() {

    rpcServer.start();

  }

  void stop() {

    closeAllScanners();

    rpcServer.stop();

  }

  /**

   * Called to verify that this server is up and running.

   *

   * @throws IOException

   */

  protected void checkOpen() throws IOException {

    if (regionServer.isStopped() || regionServer.isAborted()) {

      throw new RegionServerStoppedException("Server " + regionServer.serverName

        + " not running" + (regionServer.isAborted() ? ", aborting" : ""));

    }

    if (!regionServer.fsOk) {

      throw new RegionServerStoppedException("File system not available");

    }

    if (!regionServer.isOnline()) {

      throw new ServerNotRunningYetException("Server is not running yet");

    }

  }

  /**

   * @return list of blocking services and their security info classes that this server supports

   */

  protected List<BlockingServiceAndInterface> getServices() {

    List<BlockingServiceAndInterface> bssi = new ArrayList<BlockingServiceAndInterface>(2);

    bssi.add(new BlockingServiceAndInterface(

      ClientService.newReflectiveBlockingService(this),

      ClientService.BlockingInterface.class));

    bssi.add(new BlockingServiceAndInterface(

      AdminService.newReflectiveBlockingService(this),

      AdminService.BlockingInterface.class));

    return bssi;

  }

  @Retention(RetentionPolicy.RUNTIME)

  protected @interface QosPriority {

    int priority() default 0;

  }

  public InetSocketAddress getSocketAddress() {

    return isa;

  }

  @Override

  public int getPriority(RequestHeader header, Message param) {

    return priority.getPriority(header, param);

  }

  @Override

  public long getDeadline(RequestHeader header, Message param) {

    return priority.getDeadline(header, param);

  }

  /*

   * Check if an OOME and, if so, abort immediately to avoid creating more objects.

   *

   * @param e

   *

   * @return True if we OOME'd and are aborting.

   */

  @Override

  public boolean checkOOME(final Throwable e) {

    boolean stop = false;

    try {

      if (e instanceof OutOfMemoryError

          || (e.getCause() != null && e.getCause() instanceof OutOfMemoryError)

          || (e.getMessage() != null && e.getMessage().contains(

              "java.lang.OutOfMemoryError"))) {

        stop = true;

        LOG.fatal("Run out of memory; " + getClass().getSimpleName()

          + " will abort itself immediately", e);

      }

    } finally {

      if (stop) {

        Runtime.getRuntime().halt(1);

      }

    }

    return stop;

  }

  /**

   * Close a region on the region server.

   *

   * @param controller the RPC controller

   * @param request the request

   * @throws ServiceException

   */

  @Override

  @QosPriority(priority=HConstants.HIGH_QOS)

  public CloseRegionResponse closeRegion(final RpcController controller,

      final CloseRegionRequest request) throws ServiceException {

    final ServerName sn = (request.hasDestinationServer() ?

      ProtobufUtil.toServerName(request.getDestinationServer()) : null);

    try {

      checkOpen();

      if (request.hasServerStartCode()) {

        // check that we are the same server that this RPC is intended for.

        long serverStartCode = request.getServerStartCode();

        if (regionServer.serverName.getStartcode() !=  serverStartCode) {

          throw new ServiceException(new DoNotRetryIOException("This RPC was intended for a " +

              "different server with startCode: " + serverStartCode + ", this server is: "

              + regionServer.serverName));

        }

      }

      final String encodedRegionName = ProtobufUtil.getRegionEncodedName(request.getRegion());

      // Can be null if we're calling close on a region that's not online

      final HRegion region = regionServer.getFromOnlineRegions(encodedRegionName);

      if ((region  != null) && (region .getCoprocessorHost() != null)) {

        region.getCoprocessorHost().preClose(false);

      }

      requestCount.increment();

      LOG.info("Close " + encodedRegionName + ", moving to " + sn);

      CloseRegionCoordination.CloseRegionDetails crd = regionServer.getCoordinatedStateManager()

        .getCloseRegionCoordination().parseFromProtoRequest(request);

      boolean closed = regionServer.closeRegion(encodedRegionName, false, crd, sn);

      CloseRegionResponse.Builder builder = CloseRegionResponse.newBuilder().setClosed(closed);

      return builder.build();

    } catch (IOException ie) {

      throw new ServiceException(ie);

    }

  }

  /**

   * Compact a region on the region server.

   *

   * @param controller the RPC controller

   * @param request the request

   * @throws ServiceException

   */

  @Override

  @QosPriority(priority=HConstants.HIGH_QOS)

  public CompactRegionResponse compactRegion(final RpcController controller,

      final CompactRegionRequest request) throws ServiceException {

    try {

      checkOpen();

      requestCount.increment();

      HRegion region = getRegion(request.getRegion());

      region.startRegionOperation(Operation.COMPACT_REGION);

      LOG.info("Compacting " + region.getRegionNameAsString());

      boolean major = false;

      byte [] family = null;

      Store store = null;

      if (request.hasFamily()) {

        family = request.getFamily().toByteArray();

        store = region.getStore(family);

        if (store == null) {

          throw new ServiceException(new IOException("column family " + Bytes.toString(family)

            + " does not exist in region " + region.getRegionNameAsString()));

        }

      }

      if (request.hasMajor()) {

        major = request.getMajor();

      }

      if (major) {

        if (family != null) {

          store.triggerMajorCompaction();

        } else {

          region.triggerMajorCompaction();

        }

      }

      String familyLogMsg = (family != null)?" for column family: " + Bytes.toString(family):"";

      if (LOG.isTraceEnabled()) {

        LOG.trace("User-triggered compaction requested for region "

          + region.getRegionNameAsString() + familyLogMsg);

      }

      String log = "User-triggered " + (major ? "major " : "") + "compaction" + familyLogMsg;

      if(family != null) {

        regionServer.compactSplitThread.requestCompaction(region, store, log,

          Store.PRIORITY_USER, null);

      } else {