*

* 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.

*/

* HRegionServer makes a set of HRegions available to clients. It checks in with

* the HMaster. There are many HRegionServers in a single HBase deployment.

*/

@SuppressWarnings("deprecation")

    RegionServerServices, LastSequenceId {

  public static final Log LOG = LogFactory.getLog(HRegionServer.class);

  /**

   * For testing only!  Set to true to skip notifying region assignment to master .

   */

  @edu.umd.cs.findbugs.annotations.SuppressWarnings(value="MS_SHOULD_BE_FINAL")

  public static boolean TEST_SKIP_REPORTING_TRANSITION = false;

  /*

   * Strings to be used in forming the exception message for

   * RegionsAlreadyInTransitionException.

   */

  protected static final String OPEN = "OPEN";

  protected static final String CLOSE = "CLOSE";

  //RegionName vs current action in progress

  //true - if open region action in progress

  //false - if close region action in progress

  protected final ConcurrentMap<byte[], Boolean> regionsInTransitionInRS =

    new ConcurrentSkipListMap<byte[], Boolean>(Bytes.BYTES_COMPARATOR);

  // Cache flushing

  protected MemStoreFlusher cacheFlusher;

  protected HeapMemoryManager hMemManager;

  /*

   * Short-circuit (ie. bypassing RPC layer) HConnection to this Server

   * to be used internally for miscellaneous needs. Initialized at the server startup

   * and closed when server shuts down. Clients must never close it explicitly.

   */

  protected HConnection shortCircuitConnection;

  /*

   * Long-living meta table locator, which is created when the server is started and stopped

   * when server shuts down. References to this locator shall be used to perform according

   * operations in EventHandlers. Primary reason for this decision is to make it mockable

   * for tests.

   */

  protected MetaTableLocator metaTableLocator;

  // Watch if a region is out of recovering state from ZooKeeper

  @SuppressWarnings("unused")

  private RecoveringRegionWatcher recoveringRegionWatcher;

  /**

   * Go here to get table descriptors.

   */

  protected TableDescriptors tableDescriptors;

  // Replication services. If no replication, this handler will be null.

  protected ReplicationSourceService replicationSourceHandler;

  protected ReplicationSinkService replicationSinkHandler;

  // Compactions

  public CompactSplitThread compactSplitThread;

  /**

   * Map of regions currently being served by this region server. Key is the

   * encoded region name.  All access should be synchronized.

   */

  protected final Map<String, HRegion> onlineRegions =

    new ConcurrentHashMap<String, HRegion>();

  /**

   * Map of encoded region names to the DataNode locations they should be hosted on

   * We store the value as InetSocketAddress since this is used only in HDFS

   * API (create() that takes favored nodes as hints for placing file blocks).

   * We could have used ServerName here as the value class, but we'd need to

   * convert it to InetSocketAddress at some point before the HDFS API call, and

   * it seems a bit weird to store ServerName since ServerName refers to RegionServers

   * and here we really mean DataNode locations.

   */

  protected final Map<String, InetSocketAddress[]> regionFavoredNodesMap =

      new ConcurrentHashMap<String, InetSocketAddress[]>();

  /**

   * Set of regions currently being in recovering state which means it can accept writes(edits from

   * previous failed region server) but not reads. A recovering region is also an online region.

   */

  protected final Map<String, HRegion> recoveringRegions = Collections

      .synchronizedMap(new HashMap<String, HRegion>());

  // Leases

  protected Leases leases;

  // Instance of the hbase executor service.

  protected ExecutorService service;

  // If false, the file system has become unavailable

  protected volatile boolean fsOk;

  protected HFileSystem fs;

  // Set when a report to the master comes back with a message asking us to

  // shutdown. Also set by call to stop when debugging or running unit tests

  // of HRegionServer in isolation.

  private volatile boolean stopped = false;

  // Go down hard. Used if file system becomes unavailable and also in

  // debugging and unit tests.

  private volatile boolean abortRequested;

  ConcurrentMap<String, Integer> rowlocks = new ConcurrentHashMap<String, Integer>();

  // A state before we go into stopped state.  At this stage we're closing user

  // space regions.

  private boolean stopping = false;

  private volatile boolean killed = false;

  protected final Configuration conf;

  private Path rootDir;

  protected final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

  final int numRetries;

  protected final int threadWakeFrequency;

  protected final int msgInterval;

  protected final int numRegionsToReport;

  // Stub to do region server status calls against the master.

  private volatile RegionServerStatusService.BlockingInterface rssStub;

  // RPC client. Used to make the stub above that does region server status checking.

  RpcClient rpcClient;

  private UncaughtExceptionHandler uncaughtExceptionHandler;

  // Info server. Default access so can be used by unit tests. REGIONSERVER

  // is name of the webapp and the attribute name used stuffing this instance

  // into web context.

  protected InfoServer infoServer;

  private JvmPauseMonitor pauseMonitor;

  /** region server process name */

  public static final String REGIONSERVER = "regionserver";

  MetricsRegionServer metricsRegionServer;

  private SpanReceiverHost spanReceiverHost;

  /*

   * Check for compactions requests.

   */

  Chore compactionChecker;

  /*

   * Check for flushes

   */

  Chore periodicFlusher;

  // HLog and HLog roller. log is protected rather than private to avoid

  // eclipse warning when accessed by inner classes

  protected volatile HLog hlog;

  // The meta updates are written to a different hlog. If this

  // regionserver holds meta regions, then this field will be non-null.

  protected volatile HLog hlogForMeta;

  LogRoller hlogRoller;

  LogRoller metaHLogRoller;

  // flag set after we're done setting up server threads

  final AtomicBoolean online = new AtomicBoolean(false);

  // zookeeper connection and watcher

  protected ZooKeeperWatcher zooKeeper;

  // master address tracker

  private MasterAddressTracker masterAddressTracker;

  // Cluster Status Tracker

  protected ClusterStatusTracker clusterStatusTracker;

  // Log Splitting Worker

  private SplitLogWorker splitLogWorker;

  // A sleeper that sleeps for msgInterval.

  protected final Sleeper sleeper;

  private final int operationTimeout;

  private final RegionServerAccounting regionServerAccounting;

  // Cache configuration and block cache reference

  protected CacheConfig cacheConfig;

  /** The health check chore. */

  private HealthCheckChore healthCheckChore;

  /** The nonce manager chore. */

  private Chore nonceManagerChore;

  private Map<String, Service> coprocessorServiceHandlers = Maps.newHashMap();

  /**

   * The server name the Master sees us as.  Its made from the hostname the

   * master passes us, port, and server startcode. Gets set after registration

   * against  Master.

   */

  protected ServerName serverName;

  /**

   * This servers startcode.

   */

  protected final long startcode;

  /**

   * Unique identifier for the cluster we are a part of.

   */

  private String clusterId;

  /**

   * MX Bean for RegionServerInfo

   */

  private ObjectName mxBean = null;

  /**

   * Chore to clean periodically the moved region list

   */

  private MovedRegionsCleaner movedRegionsCleaner;

  // chore for refreshing store files for secondary regions

  private StorefileRefresherChore storefileRefresher;

  private RegionServerCoprocessorHost rsHost;

  private RegionServerProcedureManagerHost rspmHost;

  private RegionServerQuotaManager rsQuotaManager;

  // Table level lock manager for locking for region operations

  protected TableLockManager tableLockManager;

  /**

   * Nonce manager. Nonces are used to make operations like increment and append idempotent

   * in the case where client doesn't receive the response from a successful operation and

   * retries. We track the successful ops for some time via a nonce sent by client and handle

   * duplicate operations (currently, by failing them; in future we might use MVCC to return

   * result). Nonces are also recovered from WAL during, recovery; however, the caveats (from

   * HBASE-3787) are:

   * - WAL recovery is optimized, and under high load we won't read nearly nonce-timeout worth

   *   of past records. If we don't read the records, we don't read and recover the nonces.

   *   Some WALs within nonce-timeout at recovery may not even be present due to rolling/cleanup.

   * - There's no WAL recovery during normal region move, so nonces will not be transfered.

   * We can have separate additional "Nonce WAL". It will just contain bunch of numbers and

   * won't be flushed on main path - because WAL itself also contains nonces, if we only flush

   * it before memstore flush, for a given nonce we will either see it in the WAL (if it was

   * never flushed to disk, it will be part of recovery), or we'll see it as part of the nonce

   * log (or both occasionally, which doesn't matter). Nonce log file can be deleted after the

   * latest nonce in it expired. It can also be recovered during move.

   */

  final ServerNonceManager nonceManager;

  private UserProvider userProvider;

  protected final RSRpcServices rpcServices;

  protected BaseCoordinatedStateManager csm;

  /**

   * Configuration manager is used to register/deregister and notify the configuration observers

   * when the regionserver is notified that there was a change in the on disk configs.

   */

  private final ConfigurationManager configurationManager;

  /**

   * Starts a HRegionServer at the default location.

   * @param conf

   * @throws IOException

   * @throws InterruptedException

   */

  public HRegionServer(Configuration conf) throws IOException, InterruptedException {

    this(conf, CoordinatedStateManagerFactory.getCoordinatedStateManager(conf));

  }

  /**

   * Starts a HRegionServer at the default location

   * @param conf

   * @param csm implementation of CoordinatedStateManager to be used

   * @throws IOException

   */

  public HRegionServer(Configuration conf, CoordinatedStateManager csm)

      throws IOException {

    this.fsOk = true;

    this.conf = conf;

    checkCodecs(this.conf);

    this.userProvider = UserProvider.instantiate(conf);

    FSUtils.setupShortCircuitRead(this.conf);

    // Config'ed params

    this.numRetries = this.conf.getInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER,

        HConstants.DEFAULT_HBASE_CLIENT_RETRIES_NUMBER);

    this.threadWakeFrequency = conf.getInt(HConstants.THREAD_WAKE_FREQUENCY, 10 * 1000);

    this.msgInterval = conf.getInt("hbase.regionserver.msginterval", 3 * 1000);

    this.sleeper = new Sleeper(this.msgInterval, this);

    boolean isNoncesEnabled = conf.getBoolean(HConstants.HBASE_RS_NONCES_ENABLED, true);

    this.nonceManager = isNoncesEnabled ? new ServerNonceManager(this.conf) : null;

    this.numRegionsToReport = conf.getInt(

      "hbase.regionserver.numregionstoreport", 10);

    this.operationTimeout = conf.getInt(

      HConstants.HBASE_RPC_SHORTOPERATION_TIMEOUT_KEY,

      HConstants.DEFAULT_HBASE_RPC_SHORTOPERATION_TIMEOUT);

    this.abortRequested = false;

    this.stopped = false;

    rpcServices = createRpcServices();

    this.startcode = System.currentTimeMillis();

    String hostName = rpcServices.isa.getHostName();

    serverName = ServerName.valueOf(hostName, rpcServices.isa.getPort(), startcode);

    // login the zookeeper client principal (if using security)

    ZKUtil.loginClient(this.conf, "hbase.zookeeper.client.keytab.file",

      "hbase.zookeeper.client.kerberos.principal", hostName);

    // login the server principal (if using secure Hadoop)

    login(userProvider, hostName);

    regionServerAccounting = new RegionServerAccounting();

    uncaughtExceptionHandler = new UncaughtExceptionHandler() {

      @Override

      public void uncaughtException(Thread t, Throwable e) {

        abort("Uncaught exception in service thread " + t.getName(), e);

      }

    };

    // Set 'fs.defaultFS' to match the filesystem on hbase.rootdir else

    // underlying hadoop hdfs accessors will be going against wrong filesystem

    // (unless all is set to defaults).

    FSUtils.setFsDefault(this.conf, FSUtils.getRootDir(this.conf));

    // Get fs instance used by this RS.  Do we use checksum verification in the hbase? If hbase

    // checksum verification enabled, then automatically switch off hdfs checksum verification.

    boolean useHBaseChecksum = conf.getBoolean(HConstants.HBASE_CHECKSUM_VERIFICATION, true);

    this.fs = new HFileSystem(this.conf, useHBaseChecksum);

    this.rootDir = FSUtils.getRootDir(this.conf);

    this.tableDescriptors = new FSTableDescriptors(this.conf,

      this.fs, this.rootDir, !canUpdateTableDescriptor(), false);

    service = new ExecutorService(getServerName().toShortString());

    spanReceiverHost = SpanReceiverHost.getInstance(getConfiguration());

    // Some unit tests don't need a cluster, so no zookeeper at all

    if (!conf.getBoolean("hbase.testing.nocluster", false)) {

      // Open connection to zookeeper and set primary watcher

      zooKeeper = new ZooKeeperWatcher(conf, getProcessName() + ":" +

        rpcServices.isa.getPort(), this, canCreateBaseZNode());

      this.csm = (BaseCoordinatedStateManager) csm;

      this.csm.initialize(this);

      this.csm.start();

      tableLockManager = TableLockManager.createTableLockManager(

        conf, zooKeeper, serverName);

      masterAddressTracker = new MasterAddressTracker(getZooKeeper(), this);

      masterAddressTracker.start();

      clusterStatusTracker = new ClusterStatusTracker(zooKeeper, this);

      clusterStatusTracker.start();

    }

    this.configurationManager = new ConfigurationManager();

    rpcServices.start();

    putUpWebUI();

  }

  protected void login(UserProvider user, String host) throws IOException {

    user.login("hbase.regionserver.keytab.file",

      "hbase.regionserver.kerberos.principal", host);

  }

  protected void waitForMasterActive(){

  }

  protected String getProcessName() {

    return REGIONSERVER;

  }

  protected boolean canCreateBaseZNode() {

    return false;

  }

  protected boolean canUpdateTableDescriptor() {

    return false;

  }

  protected RSRpcServices createRpcServices() throws IOException {

    return new RSRpcServices(this);

  }

  protected void configureInfoServer() {

    infoServer.addServlet("rs-status", "/rs-status", RSStatusServlet.class);

    infoServer.setAttribute(REGIONSERVER, this);

  }

  protected Class<? extends HttpServlet> getDumpServlet() {

    return RSDumpServlet.class;

  }

  protected void doMetrics() {

  }

  @Override

  public boolean registerService(Service instance) {

    /*

     * No stacking of instances is allowed for a single service name

     */

    Descriptors.ServiceDescriptor serviceDesc = instance.getDescriptorForType();

    if (coprocessorServiceHandlers.containsKey(serviceDesc.getFullName())) {

      LOG.error("Coprocessor service " + serviceDesc.getFullName()

          + " already registered, rejecting request from " + instance);