001/*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements.  See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership.  The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License.  You may obtain a copy of the License at
009 *
010 *     http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018package org.apache.hadoop.hbase;
019
020import static org.apache.hadoop.hbase.io.hfile.BlockType.MAGIC_LENGTH;
021
022import java.nio.ByteBuffer;
023import java.nio.charset.Charset;
024import java.util.Arrays;
025import java.util.Collections;
026import java.util.List;
027import java.util.UUID;
028import org.apache.commons.lang3.ArrayUtils;
029import org.apache.hadoop.hbase.util.Bytes;
030import org.apache.yetus.audience.InterfaceAudience;
031
032/**
033 * HConstants holds a bunch of HBase-related constants
034 */
035@InterfaceAudience.Public
036public final class HConstants {
037  // NOTICE!!!! Please do not add a constants here, unless they are referenced by a lot of classes.
038
039  //Bytes.UTF8_ENCODING should be updated if this changed
040  /** When we encode strings, we always specify UTF8 encoding */
041  public static final String UTF8_ENCODING = "UTF-8";
042
043  //Bytes.UTF8_CHARSET should be updated if this changed
044  /** When we encode strings, we always specify UTF8 encoding */
045  public static final Charset UTF8_CHARSET = Charset.forName(UTF8_ENCODING);
046  /**
047   * Default block size for an HFile.
048   */
049  public final static int DEFAULT_BLOCKSIZE = 64 * 1024;
050
051  /** Used as a magic return value while optimized index key feature enabled(HBASE-7845) */
052  public final static int INDEX_KEY_MAGIC = -2;
053
054  /*
055   * Name of directory that holds recovered edits written by the wal log
056   * splitting code, one per region
057   */
058  public static final String RECOVERED_EDITS_DIR = "recovered.edits";
059
060  /*
061   * Name of directory that holds recovered hfiles written by the wal log
062   * splitting code, one per region
063   */
064  public static final String RECOVERED_HFILES_DIR = "recovered.hfiles";
065
066  /**
067   * Date Tiered Compaction tmp dir prefix name if use storage policy
068   */
069  public static final String STORAGE_POLICY_PREFIX = "storage_policy_";
070
071  /**
072   * The first four bytes of Hadoop RPC connections
073   */
074  public static final byte[] RPC_HEADER = new byte[] { 'H', 'B', 'a', 's' };
075  public static final byte RPC_CURRENT_VERSION = 0;
076
077  // HFileBlock constants. TODO!!!! THESE DEFINES BELONG IN HFILEBLOCK, NOT UP HERE.
078  // Needed down in hbase-common though by encoders but these encoders should not be dealing
079  // in the internals of hfileblocks. Fix encapsulation.
080
081  /** The size data structures with minor version is 0 */
082  public static final int HFILEBLOCK_HEADER_SIZE_NO_CHECKSUM = MAGIC_LENGTH + 2 * Bytes.SIZEOF_INT
083      + Bytes.SIZEOF_LONG;
084  /** The size of a version 2 HFile block header, minor version 1.
085   * There is a 1 byte checksum type, followed by a 4 byte bytesPerChecksum
086   * followed by another 4 byte value to store sizeofDataOnDisk.
087   */
088  public static final int HFILEBLOCK_HEADER_SIZE = HFILEBLOCK_HEADER_SIZE_NO_CHECKSUM +
089    Bytes.SIZEOF_BYTE + 2 * Bytes.SIZEOF_INT;
090  /** Just an array of bytes of the right size. */
091  public static final byte[] HFILEBLOCK_DUMMY_HEADER = new byte[HFILEBLOCK_HEADER_SIZE];
092
093  //End HFileBlockConstants.
094
095  /**
096   * Status codes used for return values of bulk operations.
097   */
098  @InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.COPROC)
099  public enum OperationStatusCode {
100    NOT_RUN,
101    SUCCESS,
102    BAD_FAMILY,
103    STORE_TOO_BUSY,
104    SANITY_CHECK_FAILURE,
105    FAILURE
106  }
107
108  /** long constant for zero */
109  public static final Long ZERO_L = Long.valueOf(0L);
110  public static final String NINES = "99999999999999";
111  public static final String ZEROES = "00000000000000";
112
113  // For migration
114
115  /** name of version file */
116  public static final String VERSION_FILE_NAME = "hbase.version";
117
118  /**
119   * Current version of file system.
120   * Version 4 supports only one kind of bloom filter.
121   * Version 5 changes versions in catalog table regions.
122   * Version 6 enables blockcaching on catalog tables.
123   * Version 7 introduces hfile -- hbase 0.19 to 0.20..
124   * Version 8 introduces namespace
125   */
126  // public static final String FILE_SYSTEM_VERSION = "6";
127  public static final String FILE_SYSTEM_VERSION = "8";
128
129  // Configuration parameters
130
131  //TODO: Is having HBase homed on port 60k OK?
132
133  /** Cluster is in distributed mode or not */
134  public static final String CLUSTER_DISTRIBUTED = "hbase.cluster.distributed";
135
136  /** Config for pluggable load balancers */
137  public static final String HBASE_MASTER_LOADBALANCER_CLASS = "hbase.master.loadbalancer.class";
138
139  /** Config for balancing the cluster by table */
140  public static final String HBASE_MASTER_LOADBALANCE_BYTABLE = "hbase.master.loadbalance.bytable";
141
142  /** Config for the max percent of regions in transition */
143  public static final String HBASE_MASTER_BALANCER_MAX_RIT_PERCENT =
144      "hbase.master.balancer.maxRitPercent";
145
146  /** Default value for the max percent of regions in transition */
147  public static final double DEFAULT_HBASE_MASTER_BALANCER_MAX_RIT_PERCENT = 1.0;
148
149  /** Config for the max balancing time */
150  public static final String HBASE_BALANCER_MAX_BALANCING = "hbase.balancer.max.balancing";
151
152  /** Config for the balancer period */
153  public static final String HBASE_BALANCER_PERIOD = "hbase.balancer.period";
154
155  /** Default value for the balancer period */
156  public static final int DEFAULT_HBASE_BALANCER_PERIOD = 300000;
157
158  /**
159   * Config key for enable/disable automatically separate child regions to different region servers
160   * in the procedure of split regions. One child will be kept to the server where parent
161   * region is on, and the other child will be assigned to a random server.
162   * See HBASE-25518.
163   */
164  public static final String HBASE_ENABLE_SEPARATE_CHILD_REGIONS =
165    "hbase.master.auto.separate.child.regions.after.split.enabled";
166
167  /**
168   * Default value for automatically separate child regions to different region servers
169   * (set to "false" to keep all child regions to the server where parent region is on)
170   */
171  public static final boolean DEFAULT_HBASE_ENABLE_SEPARATE_CHILD_REGIONS = false;
172
173  /** The name of the ensemble table */
174  public static final TableName ENSEMBLE_TABLE_NAME = TableName.valueOf("hbase:ensemble");
175
176  /** Config for pluggable region normalizer */
177  public static final String HBASE_MASTER_NORMALIZER_CLASS =
178    "hbase.master.normalizer.class";
179
180  /** Cluster is standalone or pseudo-distributed */
181  public static final boolean CLUSTER_IS_LOCAL = false;
182
183  /** Default value for cluster distributed mode */
184  public static final boolean DEFAULT_CLUSTER_DISTRIBUTED = CLUSTER_IS_LOCAL;
185
186  /** default host address */
187  public static final String DEFAULT_HOST = "0.0.0.0";
188
189  /** Parameter name for port master listens on. */
190  public static final String MASTER_PORT = "hbase.master.port";
191
192  /** default port that the master listens on */
193  public static final int DEFAULT_MASTER_PORT = 16000;
194
195  /** default port for master web api */
196  public static final int DEFAULT_MASTER_INFOPORT = 16010;
197
198  /** Configuration key for master web API port */
199  public static final String MASTER_INFO_PORT = "hbase.master.info.port";
200
201  /** Configuration key for the list of master host:ports **/
202  public static final String MASTER_ADDRS_KEY = "hbase.masters";
203
204  /** Full class name of the Zookeeper based connection registry implementation */
205  public static final String ZK_CONNECTION_REGISTRY_CLASS =
206      "org.apache.hadoop.hbase.client.ZKConnectionRegistry";
207
208  /** Parameter name for the master type being backup (waits for primary to go inactive). */
209  public static final String MASTER_TYPE_BACKUP = "hbase.master.backup";
210
211  /**
212   * by default every master is a possible primary master unless the conf explicitly overrides it
213   */
214  public static final boolean DEFAULT_MASTER_TYPE_BACKUP = false;
215
216  /** Name of ZooKeeper quorum configuration parameter. */
217  public static final String ZOOKEEPER_QUORUM = "hbase.zookeeper.quorum";
218
219  /** Name of ZooKeeper quorum configuration parameter for client to locate meta. */
220  public static final String CLIENT_ZOOKEEPER_QUORUM = "hbase.client.zookeeper.quorum";
221
222  /** Client port of ZooKeeper for client to locate meta */
223  public static final String CLIENT_ZOOKEEPER_CLIENT_PORT =
224      "hbase.client.zookeeper.property.clientPort";
225
226  /** Indicate whether the client ZK are observer nodes of the server ZK */
227  public static final String CLIENT_ZOOKEEPER_OBSERVER_MODE =
228      "hbase.client.zookeeper.observer.mode";
229  /** Assuming client zk not in observer mode and master need to synchronize information */
230  public static final boolean DEFAULT_CLIENT_ZOOKEEPER_OBSERVER_MODE = false;
231
232  /** Common prefix of ZooKeeper configuration properties */
233  public static final String ZK_CFG_PROPERTY_PREFIX =
234      "hbase.zookeeper.property.";
235
236  public static final int ZK_CFG_PROPERTY_PREFIX_LEN =
237      ZK_CFG_PROPERTY_PREFIX.length();
238
239  /**
240   * The ZK client port key in the ZK properties map. The name reflects the
241   * fact that this is not an HBase configuration key.
242   */
243  public static final String CLIENT_PORT_STR = "clientPort";
244
245  /** Parameter name for the client port that the zookeeper listens on */
246  public static final String ZOOKEEPER_CLIENT_PORT =
247      ZK_CFG_PROPERTY_PREFIX + CLIENT_PORT_STR;
248
249  /** Default client port that the zookeeper listens on */
250  public static final int DEFAULT_ZOOKEEPER_CLIENT_PORT = 2181;
251
252  /** Parameter name for the root dir in ZK for this cluster */
253  public static final String ZOOKEEPER_ZNODE_PARENT = "zookeeper.znode.parent";
254
255  public static final String DEFAULT_ZOOKEEPER_ZNODE_PARENT = "/hbase";
256
257  /**
258   * Parameter name for the limit on concurrent client-side zookeeper
259   * connections
260   */
261  public static final String ZOOKEEPER_MAX_CLIENT_CNXNS =
262      ZK_CFG_PROPERTY_PREFIX + "maxClientCnxns";
263
264  /** Parameter name for the ZK data directory */
265  public static final String ZOOKEEPER_DATA_DIR =
266      ZK_CFG_PROPERTY_PREFIX + "dataDir";
267
268  /** Parameter name for the ZK tick time */
269  public static final String ZOOKEEPER_TICK_TIME =
270      ZK_CFG_PROPERTY_PREFIX + "tickTime";
271
272  /** Default limit on concurrent client-side zookeeper connections */
273  public static final int DEFAULT_ZOOKEEPER_MAX_CLIENT_CNXNS = 300;
274
275  /** Configuration key for ZooKeeper session timeout */
276  public static final String ZK_SESSION_TIMEOUT = "zookeeper.session.timeout";
277
278  /** Timeout for the ZK sync() call */
279  public static final String ZK_SYNC_BLOCKING_TIMEOUT_MS = "hbase.zookeeper.sync.timeout.millis";
280  // Choice of the default value is based on the following ZK recommendation (from docs). Keeping it
281  // lower lets the callers fail fast in case of any issues.
282  // "The clients view of the system is guaranteed to be up-to-date within a certain time bound.
283  // (On the order of tens of seconds.) Either system changes will be seen by a client within this
284  // bound, or the client will detect a service outage."
285  public static final long ZK_SYNC_BLOCKING_TIMEOUT_DEFAULT_MS = 30 * 1000;
286
287  /** Default value for ZooKeeper session timeout */
288  public static final int DEFAULT_ZK_SESSION_TIMEOUT = 90 * 1000;
289
290  /** Parameter name for port region server listens on. */
291  public static final String REGIONSERVER_PORT = "hbase.regionserver.port";
292
293  /** Default port region server listens on. */
294  public static final int DEFAULT_REGIONSERVER_PORT = 16020;
295
296  /** default port for region server web api */
297  public static final int DEFAULT_REGIONSERVER_INFOPORT = 16030;
298
299  /** A configuration key for regionserver info port */
300  public static final String REGIONSERVER_INFO_PORT =
301    "hbase.regionserver.info.port";
302
303  /** A flag that enables automatic selection of regionserver info port */
304  public static final String REGIONSERVER_INFO_PORT_AUTO =
305      REGIONSERVER_INFO_PORT + ".auto";
306
307  /** Parameter name for what region server implementation to use. */
308  public static final String REGION_SERVER_IMPL= "hbase.regionserver.impl";
309
310  /** Parameter name for what master implementation to use. */
311  public static final String MASTER_IMPL= "hbase.master.impl";
312
313  /** Parameter name for how often threads should wake up */
314  public static final String THREAD_WAKE_FREQUENCY = "hbase.server.thread.wakefrequency";
315
316  /** Default value for thread wake frequency */
317  public static final int DEFAULT_THREAD_WAKE_FREQUENCY = 10 * 1000;
318
319  /** Parameter name for how often we should try to write a version file, before failing */
320  public static final String VERSION_FILE_WRITE_ATTEMPTS = "hbase.server.versionfile.writeattempts";
321
322  /** Parameter name for how often we should try to write a version file, before failing */
323  public static final int DEFAULT_VERSION_FILE_WRITE_ATTEMPTS = 3;
324
325  /** Parameter name and default value for how often a region should perform a major compaction */
326  public static final String MAJOR_COMPACTION_PERIOD = "hbase.hregion.majorcompaction";
327  public static final long   DEFAULT_MAJOR_COMPACTION_PERIOD = 1000 * 60 * 60 * 24 * 7; // 7 days
328
329  /**
330   * Parameter name and default value for major compaction jitter.
331   * Used as a multiplier applied to {@link HConstants#MAJOR_COMPACTION_PERIOD}
332   * to cause compaction to occur a given amount of time either side of
333   * {@link HConstants#MAJOR_COMPACTION_PERIOD}.
334   * Default to 0.5 so jitter has us fall evenly either side of when the compaction should run.
335   */
336  public static final String MAJOR_COMPACTION_JITTER = "hbase.hregion.majorcompaction.jitter";
337  public static final float  DEFAULT_MAJOR_COMPACTION_JITTER = 0.50F;
338
339  /** Parameter name for the maximum batch of KVs to be used in flushes and compactions */
340  public static final String COMPACTION_KV_MAX = "hbase.hstore.compaction.kv.max";
341  public static final int COMPACTION_KV_MAX_DEFAULT = 10;
342
343  /** Parameter name for HBase instance root directory */
344  public static final String HBASE_DIR = "hbase.rootdir";
345
346  /** Parameter name for HBase client IPC pool type */
347  public static final String HBASE_CLIENT_IPC_POOL_TYPE = "hbase.client.ipc.pool.type";
348
349  /** Parameter name for HBase client IPC pool size */
350  public static final String HBASE_CLIENT_IPC_POOL_SIZE = "hbase.client.ipc.pool.size";
351
352  /** Parameter name for HBase client operation timeout. */
353  public static final String HBASE_CLIENT_OPERATION_TIMEOUT = "hbase.client.operation.timeout";
354
355  /** Parameter name for HBase client meta operation timeout. */
356  public static final String HBASE_CLIENT_META_OPERATION_TIMEOUT =
357    "hbase.client.meta.operation.timeout";
358
359  /** Default HBase client operation timeout, which is tantamount to a blocking call */
360  public static final int DEFAULT_HBASE_CLIENT_OPERATION_TIMEOUT = 1200000;
361
362  /** Parameter name for HBase client meta replica scan call timeout. */
363  public static final String HBASE_CLIENT_META_REPLICA_SCAN_TIMEOUT =
364      "hbase.client.meta.replica.scan.timeout";
365
366  /** Default HBase client meta replica scan call timeout, 1 second */
367  public static final int HBASE_CLIENT_META_REPLICA_SCAN_TIMEOUT_DEFAULT = 1000000;
368
369  /** Used to construct the name of the log directory for a region server */
370  public static final String HREGION_LOGDIR_NAME = "WALs";
371
372  /** Used to construct the name of the splitlog directory for a region server */
373  public static final String SPLIT_LOGDIR_NAME = "splitWAL";
374
375  /** Like the previous, but for old logs that are about to be deleted */
376  public static final String HREGION_OLDLOGDIR_NAME = "oldWALs";
377
378  /** Staging dir used by bulk load */
379  public static final String BULKLOAD_STAGING_DIR_NAME = "staging";
380
381  public static final String CORRUPT_DIR_NAME = "corrupt";
382
383  /** Used by HBCK to sideline backup data */
384  public static final String HBCK_SIDELINEDIR_NAME = ".hbck";
385
386  /** Any artifacts left from migration can be moved here */
387  public static final String MIGRATION_NAME = ".migration";
388
389  /** Used to construct the name of the compaction directory during compaction */
390  public static final String HREGION_COMPACTIONDIR_NAME = "compaction.dir";
391
392  /** Conf key for the max file size after which we split the region */
393  public static final String HREGION_MAX_FILESIZE =
394      "hbase.hregion.max.filesize";
395
396  /** Default maximum file size */
397  public static final long DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024 * 1024L;
398
399  /** Conf key for if we should sum overall region files size when check to split */
400  public static final String OVERALL_HREGION_FILES =
401    "hbase.hregion.split.overallfiles";
402
403  /** Default overall region files */
404  public static final boolean DEFAULT_OVERALL_HREGION_FILES = true;
405
406  /**
407   * Max size of single row for Get's or Scan's without in-row scanning flag set.
408   */
409  public static final String TABLE_MAX_ROWSIZE_KEY = "hbase.table.max.rowsize";
410
411  /**
412   * Default max row size (1 Gb).
413   */
414  public static final long TABLE_MAX_ROWSIZE_DEFAULT = 1024 * 1024 * 1024L;
415
416  /**
417   * The max number of threads used for opening and closing stores or store
418   * files in parallel
419   */
420  public static final String HSTORE_OPEN_AND_CLOSE_THREADS_MAX =
421    "hbase.hstore.open.and.close.threads.max";
422
423  /**
424   * The default number for the max number of threads used for opening and
425   * closing stores or store files in parallel
426   */
427  public static final int DEFAULT_HSTORE_OPEN_AND_CLOSE_THREADS_MAX = 1;
428
429  /**
430   * Block updates if memstore has hbase.hregion.memstore.block.multiplier
431   * times hbase.hregion.memstore.flush.size bytes.  Useful preventing
432   * runaway memstore during spikes in update traffic.
433   */
434  public static final String HREGION_MEMSTORE_BLOCK_MULTIPLIER =
435          "hbase.hregion.memstore.block.multiplier";
436
437  /**
438   * Default value for hbase.hregion.memstore.block.multiplier
439   */
440  public static final int DEFAULT_HREGION_MEMSTORE_BLOCK_MULTIPLIER = 4;
441
442  /** Conf key for the memstore size at which we flush the memstore */
443  public static final String HREGION_MEMSTORE_FLUSH_SIZE =
444      "hbase.hregion.memstore.flush.size";
445
446  public static final String HREGION_EDITS_REPLAY_SKIP_ERRORS =
447      "hbase.hregion.edits.replay.skip.errors";
448
449  public static final boolean DEFAULT_HREGION_EDITS_REPLAY_SKIP_ERRORS =
450      false;
451
452  /** Maximum value length, enforced on KeyValue construction */
453  public static final int MAXIMUM_VALUE_LENGTH = Integer.MAX_VALUE - 1;
454
455  /** name of the file for unique cluster ID */
456  public static final String CLUSTER_ID_FILE_NAME = "hbase.id";
457
458  /** Default value for cluster ID */
459  public static final String CLUSTER_ID_DEFAULT = "default-cluster";
460
461  /** Parameter name for # days to keep MVCC values during a major compaction */
462  public static final String KEEP_SEQID_PERIOD = "hbase.hstore.compaction.keep.seqId.period";
463  /** At least to keep MVCC values in hfiles for 5 days */
464  public static final int MIN_KEEP_SEQID_PERIOD = 5;
465
466  // Always store the location of the root table's HRegion.
467  // This HRegion is never split.
468
469  // region name = table + startkey + regionid. This is the row key.
470  // each row in the root and meta tables describes exactly 1 region
471  // Do we ever need to know all the information that we are storing?
472
473  // Note that the name of the root table starts with "-" and the name of the
474  // meta table starts with "." Why? it's a trick. It turns out that when we
475  // store region names in memory, we use a SortedMap. Since "-" sorts before
476  // "." (and since no other table name can start with either of these
477  // characters, the root region will always be the first entry in such a Map,
478  // followed by all the meta regions (which will be ordered by their starting
479  // row key as well), followed by all user tables. So when the Master is
480  // choosing regions to assign, it will always choose the root region first,
481  // followed by the meta regions, followed by user regions. Since the root
482  // and meta regions always need to be on-line, this ensures that they will
483  // be the first to be reassigned if the server(s) they are being served by
484  // should go down.
485
486  public static final String BASE_NAMESPACE_DIR = "data";
487
488  /** delimiter used between portions of a region name */
489  public static final int META_ROW_DELIMITER = ',';
490
491  /** The catalog family as a string*/
492  public static final String CATALOG_FAMILY_STR = "info";
493
494  /** The catalog family */
495  public static final byte [] CATALOG_FAMILY = Bytes.toBytes(CATALOG_FAMILY_STR);
496
497  /** The RegionInfo qualifier as a string */
498  public static final String REGIONINFO_QUALIFIER_STR = "regioninfo";
499
500  /** The regioninfo column qualifier */
501  public static final byte [] REGIONINFO_QUALIFIER = Bytes.toBytes(REGIONINFO_QUALIFIER_STR);
502
503  /** The server column qualifier */
504  public static final String SERVER_QUALIFIER_STR = "server";
505  /** The server column qualifier */
506  public static final byte [] SERVER_QUALIFIER = Bytes.toBytes(SERVER_QUALIFIER_STR);
507
508  /** The startcode column qualifier */
509  public static final String STARTCODE_QUALIFIER_STR = "serverstartcode";
510  /** The startcode column qualifier */
511  public static final byte [] STARTCODE_QUALIFIER = Bytes.toBytes(STARTCODE_QUALIFIER_STR);
512
513  /** The open seqnum column qualifier */
514  public static final String SEQNUM_QUALIFIER_STR = "seqnumDuringOpen";
515  /** The open seqnum column qualifier */
516  public static final byte [] SEQNUM_QUALIFIER = Bytes.toBytes(SEQNUM_QUALIFIER_STR);
517
518  /** The state column qualifier */
519  public static final String STATE_QUALIFIER_STR = "state";
520
521  public static final byte [] STATE_QUALIFIER = Bytes.toBytes(STATE_QUALIFIER_STR);
522
523  /**
524   * The serverName column qualifier. Its the server where the region is
525   * transitioning on, while column server is the server where the region is
526   * opened on. They are the same when the region is in state OPEN.
527   */
528  public static final String SERVERNAME_QUALIFIER_STR = "sn";
529
530  public static final byte [] SERVERNAME_QUALIFIER = Bytes.toBytes(SERVERNAME_QUALIFIER_STR);
531
532  /** The lower-half split region column qualifier string. */
533  public static final String SPLITA_QUALIFIER_STR = "splitA";
534  /** The lower-half split region column qualifier */
535  public static final byte [] SPLITA_QUALIFIER = Bytes.toBytes(SPLITA_QUALIFIER_STR);
536
537  /** The upper-half split region column qualifier String. */
538  public static final String SPLITB_QUALIFIER_STR = "splitB";
539  /** The upper-half split region column qualifier */
540  public static final byte [] SPLITB_QUALIFIER = Bytes.toBytes(SPLITB_QUALIFIER_STR);
541
542  /**
543   * Merge qualifier prefix.
544   * We used to only allow two regions merge; mergeA and mergeB.
545   * Now we allow many to merge. Each region to merge will be referenced
546   * in a column whose qualifier starts with this define.
547   */
548  public static final String MERGE_QUALIFIER_PREFIX_STR = "merge";
549  public static final byte [] MERGE_QUALIFIER_PREFIX =
550      Bytes.toBytes(MERGE_QUALIFIER_PREFIX_STR);
551
552  /**
553   * The lower-half merge region column qualifier
554   * @deprecated Since 2.3.0 and 2.2.1. Not used anymore. Instead we look for
555   *   the {@link #MERGE_QUALIFIER_PREFIX_STR} prefix.
556   */
557  @Deprecated
558  public static final byte[] MERGEA_QUALIFIER = Bytes.toBytes(MERGE_QUALIFIER_PREFIX_STR + "A");
559
560  /**
561   * The upper-half merge region column qualifier
562   * @deprecated Since 2.3.0 and 2.2.1. Not used anymore. Instead we look for
563   *   the {@link #MERGE_QUALIFIER_PREFIX_STR} prefix.
564   */
565  @Deprecated
566  public static final byte[] MERGEB_QUALIFIER = Bytes.toBytes(MERGE_QUALIFIER_PREFIX_STR + "B");
567
568  /** The catalog family as a string*/
569  public static final String TABLE_FAMILY_STR = "table";
570
571  /** The catalog family */
572  public static final byte [] TABLE_FAMILY = Bytes.toBytes(TABLE_FAMILY_STR);
573
574  /** The serialized table state qualifier */
575  public static final byte[] TABLE_STATE_QUALIFIER = Bytes.toBytes("state");
576
577  /** The replication barrier family as a string*/
578  public static final String REPLICATION_BARRIER_FAMILY_STR = "rep_barrier";
579
580  /** The replication barrier family */
581  public static final byte[] REPLICATION_BARRIER_FAMILY =
582      Bytes.toBytes(REPLICATION_BARRIER_FAMILY_STR);
583
584  /** The namespace family as a string */
585  public static final String NAMESPACE_FAMILY_STR = "ns";
586
587  /** The namespace family */
588  public static final byte[] NAMESPACE_FAMILY = Bytes.toBytes(NAMESPACE_FAMILY_STR);
589
590  public static final byte[] NAMESPACE_COL_DESC_QUALIFIER = Bytes.toBytes("d");
591  /**
592   * The meta table version column qualifier.
593   * We keep current version of the meta table in this column in <code>-ROOT-</code>
594   * table: i.e. in the 'info:v' column.
595   */
596  public static final byte [] META_VERSION_QUALIFIER = Bytes.toBytes("v");
597
598  /** The family str as a key in map*/
599  public static final String FAMILY_KEY_STR = "family";
600
601  /**
602   * The current version of the meta table.
603   * - pre-hbase 0.92.  There is no META_VERSION column in the root table
604   * in this case. The meta has HTableDescriptor serialized into the HRegionInfo;
605   * - version 0 is 0.92 and 0.94. Meta data has serialized HRegionInfo's using
606   * Writable serialization, and HRegionInfo's does not contain HTableDescriptors.
607   * - version 1 for 0.96+ keeps HRegionInfo data structures, but changes the
608   * byte[] serialization from Writables to Protobuf.
609   * See HRegionInfo.VERSION
610   */
611  public static final short META_VERSION = 1;
612
613  // Other constants
614
615  /**
616   * An empty byte array instance.
617   */
618  public static final byte [] EMPTY_BYTE_ARRAY = new byte [0];
619
620  /**
621   * An empty string instance.
622   */
623  public static final String EMPTY_STRING = "";
624
625  public static final ByteBuffer EMPTY_BYTE_BUFFER = ByteBuffer.wrap(EMPTY_BYTE_ARRAY);
626
627  /**
628   * Used by scanners, etc when they want to start at the beginning of a region
629   */
630  public static final byte [] EMPTY_START_ROW = EMPTY_BYTE_ARRAY;
631
632  /**
633   * Last row in a table.
634   */
635  public static final byte [] EMPTY_END_ROW = EMPTY_BYTE_ARRAY;
636
637  /**
638    * Used by scanners and others when they're trying to detect the end of a
639    * table
640    */
641  public static final byte [] LAST_ROW = EMPTY_BYTE_ARRAY;
642
643  /**
644   * Max length a row can have because of the limitation in TFile.
645   */
646  public static final int MAX_ROW_LENGTH = Short.MAX_VALUE;
647
648  /**
649   * Timestamp to use when we want to refer to the latest cell.
650   *
651   * On client side, this is the timestamp set by default when no timestamp is specified,
652   * to refer to the latest.
653   * On server side, this acts as a notation.
654   * (1) For a cell of Put, which has this notation,
655   *     its timestamp will be replaced with server's current time.
656   * (2) For a cell of Delete, which has this notation,
657   *     A. If the cell is of {@link KeyValue.Type#Delete}, HBase issues a Get operation firstly.
658   *        a. When the count of cell it gets is less than the count of cell to delete,
659   *           the timestamp of Delete cell will be replaced with server's current time.
660   *        b. When the count of cell it gets is equal to the count of cell to delete,
661   *           the timestamp of Delete cell will be replaced with the latest timestamp of cell it
662   *           gets.
663   *       (c. It is invalid and an exception will be thrown,
664   *           if the count of cell it gets is greater than the count of cell to delete,
665   *           as the max version of Get is set to the count of cell to delete.)
666   *     B. If the cell is of other Delete types, like {@link KeyValue.Type#DeleteFamilyVersion},
667   *        {@link KeyValue.Type#DeleteColumn}, or {@link KeyValue.Type#DeleteFamily},
668   *        the timestamp of Delete cell will be replaced with server's current time.
669   *
670   * So that is why it is named as "latest" but assigned as the max value of Long.
671   */
672  public static final long LATEST_TIMESTAMP = Long.MAX_VALUE;
673
674  /**
675   * LATEST_TIMESTAMP in bytes form
676   */
677  public static final byte [] LATEST_TIMESTAMP_BYTES = {
678    // big-endian
679    (byte) (LATEST_TIMESTAMP >>> 56),
680    (byte) (LATEST_TIMESTAMP >>> 48),
681    (byte) (LATEST_TIMESTAMP >>> 40),
682    (byte) (LATEST_TIMESTAMP >>> 32),
683    (byte) (LATEST_TIMESTAMP >>> 24),
684    (byte) (LATEST_TIMESTAMP >>> 16),
685    (byte) (LATEST_TIMESTAMP >>> 8),
686    (byte) LATEST_TIMESTAMP,
687  };
688
689  /**
690   * Define for 'return-all-versions'.
691   */
692  public static final int ALL_VERSIONS = Integer.MAX_VALUE;
693
694  /**
695   * Unlimited time-to-live.
696   */
697//  public static final int FOREVER = -1;
698  public static final int FOREVER = Integer.MAX_VALUE;
699
700  /**
701   * Seconds in a day, hour and minute
702   */
703  public static final int DAY_IN_SECONDS = 24 * 60 * 60;
704  public static final int HOUR_IN_SECONDS = 60 * 60;
705  public static final int MINUTE_IN_SECONDS = 60;
706
707  /**
708   * KB, MB, GB, TB equivalent to how many bytes
709   */
710  public static final long KB_IN_BYTES = 1024;
711  public static final long MB_IN_BYTES = 1024 * KB_IN_BYTES;
712  public static final long GB_IN_BYTES = 1024 * MB_IN_BYTES;
713  public static final long TB_IN_BYTES = 1024 * GB_IN_BYTES;
714
715  //TODO: although the following are referenced widely to format strings for
716  //      the shell. They really aren't a part of the public API. It would be
717  //      nice if we could put them somewhere where they did not need to be
718  //      public. They could have package visibility
719  public static final String NAME = "NAME";
720  public static final String VERSIONS = "VERSIONS";
721  public static final String IN_MEMORY = "IN_MEMORY";
722  public static final String METADATA = "METADATA";
723  public static final String CONFIGURATION = "CONFIGURATION";
724
725  /**
726   * Retrying we multiply hbase.client.pause setting by what we have in this array until we
727   * run out of array items.  Retries beyond this use the last number in the array.  So, for
728   * example, if hbase.client.pause is 1 second, and maximum retries count
729   * hbase.client.retries.number is 10, we will retry at the following intervals:
730   * 1, 2, 3, 5, 10, 20, 40, 100, 100, 100.
731   * With 100ms, a back-off of 200 means 20s
732   */
733  public static final int [] RETRY_BACKOFF = {1, 2, 3, 5, 10, 20, 40, 100, 100, 100, 100, 200, 200};
734
735  public static final String REGION_IMPL = "hbase.hregion.impl";
736
737  /**
738   * Scope tag for locally scoped data.
739   * This data will not be replicated.
740   */
741  public static final int REPLICATION_SCOPE_LOCAL = 0;
742
743  /**
744   * Scope tag for globally scoped data.
745   * This data will be replicated to all peers.
746   */
747  public static final int REPLICATION_SCOPE_GLOBAL = 1;
748
749  /**
750   * Default cluster ID, cannot be used to identify a cluster so a key with
751   * this value means it wasn't meant for replication.
752   */
753  public static final UUID DEFAULT_CLUSTER_ID = new UUID(0L,0L);
754
755  /**
756   * Parameter name for maximum number of bytes returned when calling a scanner's next method.
757   * Controlled by the client.
758   */
759  public static final String HBASE_CLIENT_SCANNER_MAX_RESULT_SIZE_KEY =
760      "hbase.client.scanner.max.result.size";
761
762  /**
763   * Parameter name for maximum number of bytes returned when calling a scanner's next method.
764   * Controlled by the server.
765   */
766  public static final String HBASE_SERVER_SCANNER_MAX_RESULT_SIZE_KEY =
767      "hbase.server.scanner.max.result.size";
768
769  /**
770   * Maximum number of bytes returned when calling a scanner's next method.
771   * Note that when a single row is larger than this limit the row is still
772   * returned completely.
773   *
774   * The default value is 2MB.
775   */
776  public static final long DEFAULT_HBASE_CLIENT_SCANNER_MAX_RESULT_SIZE = 2 * 1024 * 1024;
777
778  /**
779   * Maximum number of bytes returned when calling a scanner's next method.
780   * Note that when a single row is larger than this limit the row is still
781   * returned completely.
782   * Safety setting to protect the region server.
783   *
784   * The default value is 100MB. (a client would rarely request larger chunks on purpose)
785   */
786  public static final long DEFAULT_HBASE_SERVER_SCANNER_MAX_RESULT_SIZE = 100 * 1024 * 1024;
787
788  /**
789   * Parameter name for client pause value, used mostly as value to wait
790   * before running a retry of a failed get, region lookup, etc.
791   */
792  public static final String HBASE_CLIENT_PAUSE = "hbase.client.pause";
793
794  /**
795   * Default value of {@link #HBASE_CLIENT_PAUSE}.
796   */
797  public static final long DEFAULT_HBASE_CLIENT_PAUSE = 100;
798
799  /**
800   * Parameter name for client pause value for special case such as call queue too big, etc.
801   */
802  public static final String HBASE_CLIENT_PAUSE_FOR_CQTBE = "hbase.client.pause.cqtbe";
803
804  /**
805   * The maximum number of concurrent connections the client will maintain.
806   */
807  public static final String HBASE_CLIENT_MAX_TOTAL_TASKS = "hbase.client.max.total.tasks";
808
809  /**
810   * Default value of {@link #HBASE_CLIENT_MAX_TOTAL_TASKS}.
811   */
812  public static final int DEFAULT_HBASE_CLIENT_MAX_TOTAL_TASKS = 100;
813
814  /**
815   * The maximum number of concurrent connections the client will maintain to a single
816   * RegionServer.
817   */
818  public static final String HBASE_CLIENT_MAX_PERSERVER_TASKS = "hbase.client.max.perserver.tasks";
819
820  /**
821   * Default value of {@link #HBASE_CLIENT_MAX_PERSERVER_TASKS}.
822   */
823  public static final int DEFAULT_HBASE_CLIENT_MAX_PERSERVER_TASKS = 2;
824
825  /**
826   * The maximum number of concurrent connections the client will maintain to a single
827   * Region.
828   */
829  public static final String HBASE_CLIENT_MAX_PERREGION_TASKS = "hbase.client.max.perregion.tasks";
830
831  /**
832   * Default value of {@link #HBASE_CLIENT_MAX_PERREGION_TASKS}.
833   */
834  public static final int DEFAULT_HBASE_CLIENT_MAX_PERREGION_TASKS = 1;
835
836  /**
837   * The maximum number of concurrent pending RPC requests for one server in process level.
838   */
839  public static final String HBASE_CLIENT_PERSERVER_REQUESTS_THRESHOLD =
840      "hbase.client.perserver.requests.threshold";
841
842  /**
843   * Default value of {@link #HBASE_CLIENT_PERSERVER_REQUESTS_THRESHOLD}.
844   */
845  public static final int DEFAULT_HBASE_CLIENT_PERSERVER_REQUESTS_THRESHOLD = Integer.MAX_VALUE;
846
847
848  /**
849   * Parameter name for server pause value, used mostly as value to wait before
850   * running a retry of a failed operation.
851   */
852  public static final String HBASE_SERVER_PAUSE = "hbase.server.pause";
853
854  /**
855   * Default value of {@link #HBASE_SERVER_PAUSE}.
856   */
857  public static final int DEFAULT_HBASE_SERVER_PAUSE = 1000;
858
859  /**
860   * Parameter name for maximum retries, used as maximum for all retryable
861   * operations such as fetching of the root region from root region server,
862   * getting a cell's value, starting a row update, etc.
863   */
864  public static final String HBASE_CLIENT_RETRIES_NUMBER = "hbase.client.retries.number";
865
866  /**
867   * Default value of {@link #HBASE_CLIENT_RETRIES_NUMBER}.
868   */
869  public static final int DEFAULT_HBASE_CLIENT_RETRIES_NUMBER = 15;
870
871  public static final String HBASE_CLIENT_SERVERSIDE_RETRIES_MULTIPLIER =
872      "hbase.client.serverside.retries.multiplier";
873
874  public static final int DEFAULT_HBASE_CLIENT_SERVERSIDE_RETRIES_MULTIPLIER = 3;
875
876  /**
877   * Parameter name to set the default scanner caching for all clients.
878   */
879  public static final String HBASE_CLIENT_SCANNER_CACHING = "hbase.client.scanner.caching";
880
881  /**
882   * Default value for {@link #HBASE_CLIENT_SCANNER_CACHING}
883   */
884  public static final int DEFAULT_HBASE_CLIENT_SCANNER_CACHING = Integer.MAX_VALUE;
885
886  /**
887   * Parameter name for number of rows that will be fetched when calling next on
888   * a scanner if it is not served from memory. Higher caching values will
889   * enable faster scanners but will eat up more memory and some calls of next
890   * may take longer and longer times when the cache is empty.
891   */
892  public static final String HBASE_META_SCANNER_CACHING = "hbase.meta.scanner.caching";
893
894  /**
895   * Default value of {@link #HBASE_META_SCANNER_CACHING}.
896   */
897  public static final int DEFAULT_HBASE_META_SCANNER_CACHING = 100;
898
899  /**
900   * Parameter name for number of versions, kept by meta table.
901   */
902  public static final String HBASE_META_VERSIONS = "hbase.meta.versions";
903
904  /**
905   * Default value of {@link #HBASE_META_VERSIONS}.
906   */
907  public static final int DEFAULT_HBASE_META_VERSIONS = 3;
908
909  /**
910   * Parameter name for number of versions, kept by meta table.
911   */
912  public static final String HBASE_META_BLOCK_SIZE = "hbase.meta.blocksize";
913
914  /**
915   * Default value of {@link #HBASE_META_BLOCK_SIZE}.
916   */
917  public static final int DEFAULT_HBASE_META_BLOCK_SIZE = 8 * 1024;
918
919  /**
920   * Parameter name for unique identifier for this {@link org.apache.hadoop.conf.Configuration}
921   * instance. If there are two or more {@link org.apache.hadoop.conf.Configuration} instances that,
922   * for all intents and purposes, are the same except for their instance ids, then they will not be
923   * able to share the same org.apache.hadoop.hbase.client.HConnection instance. On the other hand,
924   * even if the instance ids are the same, it could result in non-shared
925   * org.apache.hadoop.hbase.client.HConnection instances if some of the other connection parameters
926   * differ.
927   */
928  public static final String HBASE_CLIENT_INSTANCE_ID = "hbase.client.instance.id";
929
930  /**
931   * The client scanner timeout period in milliseconds.
932   */
933  public static final String HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD =
934      "hbase.client.scanner.timeout.period";
935
936  /**
937   * Default value of {@link #HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD}.
938   */
939  public static final int DEFAULT_HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD = 60000;
940
941  /**
942   * timeout for each RPC
943   */
944  public static final String HBASE_RPC_TIMEOUT_KEY = "hbase.rpc.timeout";
945
946  /**
947   * timeout for each read RPC
948   */
949  public static final String HBASE_RPC_READ_TIMEOUT_KEY = "hbase.rpc.read.timeout";
950
951  /**
952   * timeout for each write RPC
953   */
954  public static final String HBASE_RPC_WRITE_TIMEOUT_KEY = "hbase.rpc.write.timeout";
955
956  /**
957   * Default value of {@link #HBASE_RPC_TIMEOUT_KEY}
958   */
959  public static final int DEFAULT_HBASE_RPC_TIMEOUT = 60000;
960
961  /**
962   * timeout for short operation RPC
963   */
964  public static final String HBASE_RPC_SHORTOPERATION_TIMEOUT_KEY =
965      "hbase.rpc.shortoperation.timeout";
966
967  /**
968   * Default value of {@link #HBASE_RPC_SHORTOPERATION_TIMEOUT_KEY}
969   */
970  public static final int DEFAULT_HBASE_RPC_SHORTOPERATION_TIMEOUT = 10000;
971
972  /**
973   * Retry pause time for short operation RPC
974   */
975  public static final String HBASE_RPC_SHORTOPERATION_RETRY_PAUSE_TIME =
976      "hbase.rpc.shortoperation.retry.pause.time";
977
978  /**
979   * Default value of {@link #HBASE_RPC_SHORTOPERATION_RETRY_PAUSE_TIME}
980   */
981  public static final long DEFAULT_HBASE_RPC_SHORTOPERATION_RETRY_PAUSE_TIME = 1000;
982
983  /**
984   * Value indicating the server name was saved with no sequence number.
985   */
986  public static final long NO_SEQNUM = -1;
987
988  /**
989   * Registry implementation to be used on the client side.
990   */
991  public static final String CLIENT_CONNECTION_REGISTRY_IMPL_CONF_KEY =
992      "hbase.client.registry.impl";
993
994  /*
995   * cluster replication constants.
996   */
997  public static final String
998      REPLICATION_SOURCE_SERVICE_CLASSNAME = "hbase.replication.source.service";
999  public static final String REPLICATION_SERVICE_CLASSNAME_DEFAULT =
1000    "org.apache.hadoop.hbase.replication.regionserver.Replication";
1001  public static final String
1002      REPLICATION_SINK_SERVICE_CLASSNAME = "hbase.replication.sink.service";
1003  public static final String REPLICATION_SINK_SERVICE_CLASSNAME_DEFAULT =
1004    "org.apache.hadoop.hbase.replication.ReplicationSinkServiceImpl";
1005  public static final String REPLICATION_BULKLOAD_ENABLE_KEY = "hbase.replication.bulkload.enabled";
1006  public static final boolean REPLICATION_BULKLOAD_ENABLE_DEFAULT = false;
1007  /** Replication cluster id of source cluster which uniquely identifies itself with peer cluster */
1008  public static final String REPLICATION_CLUSTER_ID = "hbase.replication.cluster.id";
1009  /**
1010   * Max total size of buffered entries in all replication peers. It will prevent server getting
1011   * OOM if there are many peers. Default value is 256MB which is four times to default
1012   * replication.source.size.capacity.
1013   */
1014  public static final String REPLICATION_SOURCE_TOTAL_BUFFER_KEY = "replication.total.buffer.quota";
1015
1016  public static final int REPLICATION_SOURCE_TOTAL_BUFFER_DFAULT = 256 * 1024 * 1024;
1017
1018  /** Configuration key for ReplicationSource shipeEdits timeout */
1019  public static final String REPLICATION_SOURCE_SHIPEDITS_TIMEOUT =
1020      "replication.source.shipedits.timeout";
1021  public static final int REPLICATION_SOURCE_SHIPEDITS_TIMEOUT_DFAULT = 60000;
1022
1023  /**
1024   * Directory where the source cluster file system client configuration are placed which is used by
1025   * sink cluster to copy HFiles from source cluster file system
1026   */
1027  public static final String REPLICATION_CONF_DIR = "hbase.replication.conf.dir";
1028
1029  /** Maximum time to retry for a failed bulk load request */
1030  public static final String BULKLOAD_MAX_RETRIES_NUMBER = "hbase.bulkload.retries.number";
1031
1032  public static final String KEY_FOR_HOSTNAME_SEEN_BY_MASTER =
1033    "hbase.regionserver.hostname.seen.by.master";
1034
1035  public static final String HBASE_MASTER_LOGCLEANER_PLUGINS =
1036      "hbase.master.logcleaner.plugins";
1037
1038  public static final String HBASE_REGION_SPLIT_POLICY_KEY =
1039    "hbase.regionserver.region.split.policy";
1040
1041  /** Whether nonces are enabled; default is true. */
1042  public static final String HBASE_RS_NONCES_ENABLED = "hbase.regionserver.nonces.enabled";
1043
1044  /**
1045   * Configuration key for the size of the block cache
1046   */
1047  public static final String HFILE_BLOCK_CACHE_SIZE_KEY =
1048    "hfile.block.cache.size";
1049
1050  public static final float HFILE_BLOCK_CACHE_SIZE_DEFAULT = 0.4f;
1051
1052  /**
1053   * Configuration key for setting the fix size of the block size, default do nothing and it should
1054   * be explicitly set by user or only used within ClientSideRegionScanner. if it's set less than
1055   * current max on heap size, it overrides the max size of block cache
1056   */
1057  public static final String HFILE_ONHEAP_BLOCK_CACHE_FIXED_SIZE_KEY =
1058    "hfile.onheap.block.cache.fixed.size";
1059  public static final long HFILE_ONHEAP_BLOCK_CACHE_FIXED_SIZE_DEFAULT = 0L;
1060  public static final long HBASE_CLIENT_SCANNER_ONHEAP_BLOCK_CACHE_FIXED_SIZE_DEFAULT =
1061    32 * 1024 * 1024L;
1062
1063  /*
1064    * Minimum percentage of free heap necessary for a successful cluster startup.
1065    */
1066  public static final float HBASE_CLUSTER_MINIMUM_MEMORY_THRESHOLD = 0.2f;
1067
1068
1069  public static final String CP_HTD_ATTR_INCLUSION_KEY =
1070      "hbase.coprocessor.classloader.included.classes";
1071
1072  /** The delay when re-trying a socket operation in a loop (HBASE-4712) */
1073  public static final int SOCKET_RETRY_WAIT_MS = 200;
1074
1075  /** Host name of the local machine */
1076  public static final String LOCALHOST = "localhost";
1077
1078  /**
1079   * If this parameter is set to true, then hbase will read
1080   * data and then verify checksums. Checksum verification
1081   * inside hdfs will be switched off.  However, if the hbase-checksum
1082   * verification fails, then it will switch back to using
1083   * hdfs checksums for verifiying data that is being read from storage.
1084   *
1085   * If this parameter is set to false, then hbase will not
1086   * verify any checksums, instead it will depend on checksum verification
1087   * being done in the hdfs client.
1088   */
1089  public static final String HBASE_CHECKSUM_VERIFICATION =
1090      "hbase.regionserver.checksum.verify";
1091
1092  public static final String LOCALHOST_IP = "127.0.0.1";
1093
1094  public static final String REGION_SERVER_HANDLER_COUNT = "hbase.regionserver.handler.count";
1095  public static final int DEFAULT_REGION_SERVER_HANDLER_COUNT = 30;
1096
1097  /*
1098   * REGION_SERVER_HANDLER_ABORT_ON_ERROR_PERCENT:
1099   * -1  => Disable aborting
1100   * 0   => Abort if even a single handler has died
1101   * 0.x => Abort only when this percent of handlers have died
1102   * 1   => Abort only all of the handers have died
1103   */
1104  public static final String REGION_SERVER_HANDLER_ABORT_ON_ERROR_PERCENT =
1105      "hbase.regionserver.handler.abort.on.error.percent";
1106  public static final double DEFAULT_REGION_SERVER_HANDLER_ABORT_ON_ERROR_PERCENT = 0.5;
1107
1108  //High priority handlers to deal with admin requests and system table operation requests
1109  public static final String REGION_SERVER_HIGH_PRIORITY_HANDLER_COUNT =
1110      "hbase.regionserver.metahandler.count";
1111  public static final int DEFAULT_REGION_SERVER_HIGH_PRIORITY_HANDLER_COUNT = 20;
1112
1113  public static final String REGION_SERVER_REPLICATION_HANDLER_COUNT =
1114      "hbase.regionserver.replication.handler.count";
1115  public static final int DEFAULT_REGION_SERVER_REPLICATION_HANDLER_COUNT = 3;
1116  // Meta Transition handlers to deal with meta ReportRegionStateTransitionRequest. Meta transition
1117  // should be dealt with in a separate handler in case blocking other region's transition.
1118  public static final String MASTER_META_TRANSITION_HANDLER_COUNT =
1119      "hbase.master.meta.transition.handler.count";
1120  public static final int MASTER__META_TRANSITION_HANDLER_COUNT_DEFAULT = 1;
1121
1122  /** Conf key for enabling meta replication */
1123  public static final String USE_META_REPLICAS = "hbase.meta.replicas.use";
1124  public static final boolean DEFAULT_USE_META_REPLICAS = false;
1125
1126  /**
1127   * @deprecated Since 2.4.0, will be removed in 4.0.0. Please change the meta replicas number by
1128   *             altering meta table, i.e, set a new 'region replication' number and call
1129   *             modifyTable.
1130   */
1131  @Deprecated
1132  public static final String META_REPLICAS_NUM = "hbase.meta.replica.count";
1133  /**
1134   * @deprecated Since 2.4.0, will be removed in 4.0.0. Please change the meta replicas number by
1135   *             altering meta table, i.e, set a new 'region replication' number and call
1136   *             modifyTable.
1137   */
1138  @Deprecated
1139  public static final int DEFAULT_META_REPLICA_NUM = 1;
1140
1141  /**
1142   * The name of the configuration parameter that specifies
1143   * the number of bytes in a newly created checksum chunk.
1144   */
1145  public static final String BYTES_PER_CHECKSUM =
1146      "hbase.hstore.bytes.per.checksum";
1147
1148  /**
1149   * The name of the configuration parameter that specifies
1150   * the name of an algorithm that is used to compute checksums
1151   * for newly created blocks.
1152   */
1153  public static final String CHECKSUM_TYPE_NAME =
1154      "hbase.hstore.checksum.algorithm";
1155
1156  /** Enable file permission modification from standard hbase */
1157  public static final String ENABLE_DATA_FILE_UMASK = "hbase.data.umask.enable";
1158  /** File permission umask to use when creating hbase data files */
1159  public static final String DATA_FILE_UMASK_KEY = "hbase.data.umask";
1160
1161  /** Configuration name of WAL Compression */
1162  public static final String ENABLE_WAL_COMPRESSION =
1163    "hbase.regionserver.wal.enablecompression";
1164
1165  /** Configuration name of WAL storage policy
1166   * Valid values are: HOT, COLD, WARM, ALL_SSD, ONE_SSD, LAZY_PERSIST
1167   * See http://hadoop.apache.org/docs/r2.7.3/hadoop-project-dist/hadoop-hdfs/ArchivalStorage.html*/
1168  public static final String WAL_STORAGE_POLICY = "hbase.wal.storage.policy";
1169  /**
1170   * "NONE" is not a valid storage policy and means we defer the policy to HDFS. @see
1171   * <a href="https://issues.apache.org/jira/browse/HBASE-20691">HBASE-20691</a>
1172   */
1173  public static final String DEFER_TO_HDFS_STORAGE_POLICY = "NONE";
1174  /** By default we defer the WAL storage policy to HDFS */
1175  public static final String DEFAULT_WAL_STORAGE_POLICY = DEFER_TO_HDFS_STORAGE_POLICY;
1176
1177  /** Region in Transition metrics threshold time */
1178  public static final String METRICS_RIT_STUCK_WARNING_THRESHOLD =
1179      "hbase.metrics.rit.stuck.warning.threshold";
1180
1181  public static final String LOAD_BALANCER_SLOP_KEY = "hbase.regions.slop";
1182
1183  /** delimiter used between portions of a region name */
1184  public static final int DELIMITER = ',';
1185
1186  /**
1187   * QOS attributes: these attributes are used to demarcate RPC call processing
1188   * by different set of handlers. For example, HIGH_QOS tagged methods are
1189   * handled by high priority handlers.
1190   */
1191  // normal_QOS < replication_QOS < replay_QOS < QOS_threshold < admin_QOS < high_QOS < meta_QOS
1192  public static final int PRIORITY_UNSET = -1;
1193  public static final int NORMAL_QOS = 0;
1194  public static final int REPLICATION_QOS = 5;
1195  public static final int REPLAY_QOS = 6;
1196  public static final int QOS_THRESHOLD = 10;
1197  public static final int ADMIN_QOS = 100;
1198  public static final int HIGH_QOS = 200;
1199  public static final int SYSTEMTABLE_QOS = HIGH_QOS;
1200
1201  /** Directory under /hbase where archived hfiles are stored */
1202  public static final String HFILE_ARCHIVE_DIRECTORY = "archive";
1203
1204  /**
1205   * Name of the directory to store all snapshots. See SnapshotDescriptionUtils for
1206   * remaining snapshot constants; this is here to keep HConstants dependencies at a minimum and
1207   * uni-directional.
1208   */
1209  public static final String SNAPSHOT_DIR_NAME = ".hbase-snapshot";
1210
1211  /* Name of old snapshot directory. See HBASE-8352 for details on why it needs to be renamed */
1212  public static final String OLD_SNAPSHOT_DIR_NAME = ".snapshot";
1213
1214  /** Temporary directory used for table creation and deletion */
1215  public static final String HBASE_TEMP_DIRECTORY = ".tmp";
1216  /**
1217   * The period (in milliseconds) between computing region server point in time metrics
1218   */
1219  public static final String REGIONSERVER_METRICS_PERIOD = "hbase.regionserver.metrics.period";
1220  public static final long DEFAULT_REGIONSERVER_METRICS_PERIOD = 5000;
1221  /** Directories that are not HBase table directories */
1222  public static final List<String> HBASE_NON_TABLE_DIRS =
1223    Collections.unmodifiableList(Arrays.asList(new String[] {
1224      HBCK_SIDELINEDIR_NAME, HBASE_TEMP_DIRECTORY, MIGRATION_NAME
1225    }));
1226
1227  /**
1228   * Directories that are not HBase user table directories.
1229   * @deprecated Since hbase-2.3.0; no replacement as not used any more (internally at least)
1230   */
1231  @Deprecated
1232  public static final List<String> HBASE_NON_USER_TABLE_DIRS =
1233    Collections.unmodifiableList(Arrays.asList((String[])ArrayUtils.addAll(
1234      new String[] { TableName.META_TABLE_NAME.getNameAsString() },
1235      HBASE_NON_TABLE_DIRS.toArray())));
1236
1237  /** Health script related settings. */
1238  public static final String HEALTH_SCRIPT_LOC = "hbase.node.health.script.location";
1239  public static final String HEALTH_SCRIPT_TIMEOUT = "hbase.node.health.script.timeout";
1240  public static final String HEALTH_CHORE_WAKE_FREQ =
1241      "hbase.node.health.script.frequency";
1242  public static final long DEFAULT_HEALTH_SCRIPT_TIMEOUT = 60000;
1243  /**
1244   * The maximum number of health check failures a server can encounter consecutively.
1245   */
1246  public static final String HEALTH_FAILURE_THRESHOLD =
1247      "hbase.node.health.failure.threshold";
1248  public static final int DEFAULT_HEALTH_FAILURE_THRESHOLD = 3;
1249
1250  public static final String EXECUTOR_STATUS_COLLECT_ENABLED =
1251      "hbase.executors.status.collect.enabled";
1252  public static final boolean DEFAULT_EXECUTOR_STATUS_COLLECT_ENABLED = true;
1253
1254  /**
1255   * Setting to activate, or not, the publication of the status by the master. Default
1256   *  notification is by a multicast message.
1257   */
1258  public static final String STATUS_PUBLISHED = "hbase.status.published";
1259  public static final boolean STATUS_PUBLISHED_DEFAULT = false;
1260
1261  /**
1262   * IP to use for the multicast status messages between the master and the clients.
1263   * The default address is chosen as one among others within the ones suitable for multicast
1264   * messages.
1265   */
1266  public static final String STATUS_MULTICAST_ADDRESS = "hbase.status.multicast.address.ip";
1267  public static final String DEFAULT_STATUS_MULTICAST_ADDRESS = "226.1.1.3";
1268
1269  /**
1270   * The address to use for binding the local socket for receiving multicast. Defaults to
1271   * 0.0.0.0.
1272   * @see <a href="https://issues.apache.org/jira/browse/HBASE-9961">HBASE-9961</a>
1273   */
1274  public static final String STATUS_MULTICAST_BIND_ADDRESS =
1275      "hbase.status.multicast.bind.address.ip";
1276  public static final String DEFAULT_STATUS_MULTICAST_BIND_ADDRESS = "0.0.0.0";
1277
1278  /**
1279   * The port to use for the multicast messages.
1280   */
1281  public static final String STATUS_MULTICAST_PORT = "hbase.status.multicast.address.port";
1282  public static final int DEFAULT_STATUS_MULTICAST_PORT = 16100;
1283
1284  /**
1285   * The network interface name to use for the multicast messages.
1286   */
1287  public static final String STATUS_MULTICAST_NI_NAME = "hbase.status.multicast.ni.name";
1288
1289  /**
1290   * The address to use for binding the local socket for sending multicast. Defaults to 0.0.0.0.
1291   */
1292  public static final String STATUS_MULTICAST_PUBLISHER_BIND_ADDRESS =
1293    "hbase.status.multicast.publisher.bind.address.ip";
1294  public static final String DEFAULT_STATUS_MULTICAST_PUBLISHER_BIND_ADDRESS = "0.0.0.0";
1295
1296  public static final long NO_NONCE = 0;
1297
1298  /** Default cipher for encryption */
1299  public static final String CIPHER_AES = "AES";
1300
1301  /** Configuration key for the crypto algorithm provider, a class name */
1302  public static final String CRYPTO_CIPHERPROVIDER_CONF_KEY = "hbase.crypto.cipherprovider";
1303
1304  /** Configuration key for the crypto key provider, a class name */
1305  public static final String CRYPTO_KEYPROVIDER_CONF_KEY = "hbase.crypto.keyprovider";
1306
1307  /** Configuration key for the crypto key provider parameters */
1308  public static final String CRYPTO_KEYPROVIDER_PARAMETERS_KEY =
1309      "hbase.crypto.keyprovider.parameters";
1310
1311  /** Configuration key for the name of the master key for the cluster, a string */
1312  public static final String CRYPTO_MASTERKEY_NAME_CONF_KEY = "hbase.crypto.master.key.name";
1313
1314  /** Configuration key for the name of the alternate master key for the cluster, a string */
1315  public static final String CRYPTO_MASTERKEY_ALTERNATE_NAME_CONF_KEY =
1316    "hbase.crypto.master.alternate.key.name";
1317
1318  /** Configuration key for the algorithm to use when encrypting the WAL, a string */
1319  public static final String CRYPTO_WAL_ALGORITHM_CONF_KEY = "hbase.crypto.wal.algorithm";
1320
1321  /** Configuration key for the name of the master WAL encryption key for the cluster, a string */
1322  public static final String CRYPTO_WAL_KEY_NAME_CONF_KEY = "hbase.crypto.wal.key.name";
1323
1324  /** Configuration key for the algorithm used for creating jks key, a string */
1325  public static final String CRYPTO_KEY_ALGORITHM_CONF_KEY = "hbase.crypto.key.algorithm";
1326
1327  /** Configuration key for the name of the alternate cipher algorithm for the cluster, a string */
1328  public static final String CRYPTO_ALTERNATE_KEY_ALGORITHM_CONF_KEY =
1329      "hbase.crypto.alternate.key.algorithm";
1330
1331  /** Configuration key for enabling WAL encryption, a boolean */
1332  public static final String ENABLE_WAL_ENCRYPTION = "hbase.regionserver.wal.encryption";
1333
1334  /** Configuration key for setting RPC codec class name */
1335  public static final String RPC_CODEC_CONF_KEY = "hbase.client.rpc.codec";
1336
1337  /** Configuration key for setting replication codec class name */
1338  public static final String REPLICATION_CODEC_CONF_KEY = "hbase.replication.rpc.codec";
1339
1340  /** Maximum number of threads used by the replication source for shipping edits to the sinks */
1341  public static final String REPLICATION_SOURCE_MAXTHREADS_KEY =
1342      "hbase.replication.source.maxthreads";
1343
1344  /**
1345   * Drop edits for tables that been deleted from the replication source and target
1346   * @deprecated since 3.0.0. Will be removed in 4.0.0.
1347   *             Moved it into HBaseInterClusterReplicationEndpoint.
1348   * @see <a href="https://issues.apache.org/jira/browse/HBASE-24359">HBASE-24359</a>
1349   */
1350  @Deprecated
1351  public static final String REPLICATION_DROP_ON_DELETED_TABLE_KEY =
1352      "hbase.replication.drop.on.deleted.table";
1353
1354  /** Maximum number of threads used by the replication source for shipping edits to the sinks */
1355  public static final int REPLICATION_SOURCE_MAXTHREADS_DEFAULT = 10;
1356
1357  /** Configuration key for SplitLog manager timeout */
1358  public static final String HBASE_SPLITLOG_MANAGER_TIMEOUT = "hbase.splitlog.manager.timeout";
1359
1360  /**
1361   * Configuration keys for Bucket cache
1362   */
1363  // TODO moving these bucket cache implementation specific configs to this level is violation of
1364  // encapsulation. But as these has to be referred from hbase-common and bucket cache
1365  // sits in hbase-server, there were no other go! Can we move the cache implementation to
1366  // hbase-common?
1367
1368  /**
1369   * Current ioengine options in include: heap, offheap and file:PATH (where PATH is the path
1370   * to the file that will host the file-based cache.  See BucketCache#getIOEngineFromName() for
1371   * list of supported ioengine options.
1372   * <p>Set this option and a non-zero {@link #BUCKET_CACHE_SIZE_KEY} to enable bucket cache.
1373   */
1374  public static final String BUCKET_CACHE_IOENGINE_KEY = "hbase.bucketcache.ioengine";
1375
1376  /**
1377   * When using bucket cache, it is the capacity in megabytes of the cache.
1378   */
1379  public static final String BUCKET_CACHE_SIZE_KEY = "hbase.bucketcache.size";
1380
1381  /**
1382   * HConstants for fast fail on the client side follow
1383   */
1384  /**
1385   * Config for enabling/disabling the fast fail mode.
1386   * @deprecated since 2.3.0, and in 3.0.0 the actually implementation will be removed so config
1387   *             this value will have no effect. The constants itself will be removed in 4.0.0.
1388   */
1389  @Deprecated
1390  public static final String HBASE_CLIENT_FAST_FAIL_MODE_ENABLED =
1391    "hbase.client.fast.fail.mode.enabled";
1392
1393  /**
1394   * @deprecated since 2.3.0, and in 3.0.0 the actually implementation will be removed so config
1395   *             this value will have no effect. The constants itself will be removed in 4.0.0.
1396   */
1397  @Deprecated
1398  public static final boolean HBASE_CLIENT_ENABLE_FAST_FAIL_MODE_DEFAULT = false;
1399
1400  /**
1401   * @deprecated since 2.3.0, and in 3.0.0 the actually implementation will be removed so config
1402   *             this value will have no effect. The constants itself will be removed in 4.0.0.
1403   */
1404  @Deprecated
1405  public static final String HBASE_CLIENT_FAST_FAIL_THREASHOLD_MS =
1406    "hbase.client.fastfail.threshold";
1407
1408  /**
1409   * @deprecated since 2.3.0, and in 3.0.0 the actually implementation will be removed so config
1410   *             this value will have no effect. The constants itself will be removed in 4.0.0.
1411   */
1412  @Deprecated
1413  public static final long HBASE_CLIENT_FAST_FAIL_THREASHOLD_MS_DEFAULT = 60000;
1414
1415  /**
1416   * @deprecated since 2.3.0, and in 3.0.0 the actually implementation will be removed so config
1417   *             this value will have no effect. The constants itself will be removed in 4.0.0.
1418   */
1419  @Deprecated
1420  public static final String HBASE_CLIENT_FAILURE_MAP_CLEANUP_INTERVAL_MS =
1421    "hbase.client.failure.map.cleanup.interval";
1422
1423  /**
1424   * @deprecated since 2.3.0, and in 3.0.0 the actually implementation will be removed so config
1425   *             this value will have no effect. The constants itself will be removed in 4.0.0.
1426   */
1427  @Deprecated
1428  public static final long HBASE_CLIENT_FAILURE_MAP_CLEANUP_INTERVAL_MS_DEFAULT = 600000;
1429
1430  /**
1431   * @deprecated since 2.3.0, and in 3.0.0 the actually implementation will be removed so config
1432   *             this value will have no effect. The constants itself will be removed in 4.0.0.
1433   */
1434  @Deprecated
1435  public static final String HBASE_CLIENT_FAST_FAIL_CLEANUP_MS_DURATION_MS =
1436    "hbase.client.fast.fail.cleanup.duration";
1437
1438  /**
1439   * @deprecated since 2.3.0, and in 3.0.0 the actually implementation will be removed so config
1440   *             this value will have no effect. The constants itself will be removed in 4.0.0.
1441   */
1442  @Deprecated
1443  public static final long HBASE_CLIENT_FAST_FAIL_CLEANUP_DURATION_MS_DEFAULT = 600000;
1444
1445  /**
1446   * @deprecated since 2.3.0, and in 3.0.0 the actually implementation will be removed so config
1447   *             this value will have no effect. The constants itself will be removed in 4.0.0.
1448   */
1449  @Deprecated
1450  public static final String HBASE_CLIENT_FAST_FAIL_INTERCEPTOR_IMPL =
1451    "hbase.client.fast.fail.interceptor.impl";
1452
1453  /**
1454   * @deprecated since 2.4.0 and in 3.0.0, to be removed in 4.0.0, replaced by procedure-based
1455   *   distributed WAL splitter; see SplitWALManager.
1456   */
1457  @Deprecated
1458  public static final String HBASE_SPLIT_WAL_COORDINATED_BY_ZK = "hbase.split.wal.zk.coordinated";
1459
1460  /**
1461   * @deprecated since 2.4.0 and in 3.0.0, to be removed in 4.0.0.
1462   */
1463  @Deprecated
1464  public static final boolean DEFAULT_HBASE_SPLIT_COORDINATED_BY_ZK = false;
1465
1466  public static final String HBASE_SPLIT_WAL_MAX_SPLITTER = "hbase.regionserver.wal.max.splitters";
1467
1468  public static final int DEFAULT_HBASE_SPLIT_WAL_MAX_SPLITTER = 2;
1469
1470  /** Config key for if the server should send backpressure and if the client should listen to
1471   * that backpressure from the server */
1472  public static final String ENABLE_CLIENT_BACKPRESSURE = "hbase.client.backpressure.enabled";
1473  public static final boolean DEFAULT_ENABLE_CLIENT_BACKPRESSURE = false;
1474
1475  public static final String HEAP_OCCUPANCY_LOW_WATERMARK_KEY =
1476      "hbase.heap.occupancy.low_water_mark";
1477  public static final float DEFAULT_HEAP_OCCUPANCY_LOW_WATERMARK = 0.95f;
1478  public static final String HEAP_OCCUPANCY_HIGH_WATERMARK_KEY =
1479      "hbase.heap.occupancy.high_water_mark";
1480  public static final float DEFAULT_HEAP_OCCUPANCY_HIGH_WATERMARK = 0.98f;
1481
1482  /**
1483   * The max number of threads used for splitting storefiles in parallel during
1484   * the region split process.
1485   */
1486  public static final String REGION_SPLIT_THREADS_MAX =
1487    "hbase.regionserver.region.split.threads.max";
1488
1489  /** Canary config keys */
1490  // TODO: Move these defines to Canary Class
1491  public static final String HBASE_CANARY_WRITE_DATA_TTL_KEY = "hbase.canary.write.data.ttl";
1492
1493  public static final String HBASE_CANARY_WRITE_PERSERVER_REGIONS_LOWERLIMIT_KEY =
1494      "hbase.canary.write.perserver.regions.lowerLimit";
1495
1496  public static final String HBASE_CANARY_WRITE_PERSERVER_REGIONS_UPPERLIMIT_KEY =
1497      "hbase.canary.write.perserver.regions.upperLimit";
1498
1499  public static final String HBASE_CANARY_WRITE_VALUE_SIZE_KEY = "hbase.canary.write.value.size";
1500
1501  public static final String HBASE_CANARY_WRITE_TABLE_CHECK_PERIOD_KEY =
1502      "hbase.canary.write.table.check.period";
1503
1504  public static final String HBASE_CANARY_READ_RAW_SCAN_KEY = "hbase.canary.read.raw.enabled";
1505
1506  public static final String HBASE_CANARY_READ_ALL_CF = "hbase.canary.read.all.column.famliy";
1507  /**
1508   * Configuration keys for programmatic JAAS configuration for secured ZK interaction
1509   */
1510  public static final String ZK_CLIENT_KEYTAB_FILE = "hbase.zookeeper.client.keytab.file";
1511  public static final String ZK_CLIENT_KERBEROS_PRINCIPAL =
1512      "hbase.zookeeper.client.kerberos.principal";
1513  public static final String ZK_SERVER_KEYTAB_FILE = "hbase.zookeeper.server.keytab.file";
1514  public static final String ZK_SERVER_KERBEROS_PRINCIPAL =
1515      "hbase.zookeeper.server.kerberos.principal";
1516
1517  /** Config key for hbase temporary directory in hdfs */
1518  public static final String TEMPORARY_FS_DIRECTORY_KEY = "hbase.fs.tmp.dir";
1519
1520  /**
1521   * Don't use it! This'll get you the wrong path in a secure cluster.
1522   * Use FileSystem.getHomeDirectory() or
1523   * "/user/" + UserGroupInformation.getCurrentUser().getShortUserName()
1524   */
1525  public static final String DEFAULT_TEMPORARY_HDFS_DIRECTORY = "/user/"
1526      + System.getProperty("user.name") + "/hbase-staging";
1527
1528  public static final String SNAPSHOT_RESTORE_TAKE_FAILSAFE_SNAPSHOT =
1529      "hbase.snapshot.restore.take.failsafe.snapshot";
1530  public static final boolean DEFAULT_SNAPSHOT_RESTORE_TAKE_FAILSAFE_SNAPSHOT = true;
1531
1532  public static final String SNAPSHOT_RESTORE_FAILSAFE_NAME =
1533      "hbase.snapshot.restore.failsafe.name";
1534  public static final String DEFAULT_SNAPSHOT_RESTORE_FAILSAFE_NAME =
1535      "hbase-failsafe-{snapshot.name}-{restore.timestamp}";
1536
1537  public static final String DEFAULT_LOSSY_COUNTING_ERROR_RATE =
1538      "hbase.util.default.lossycounting.errorrate";
1539  public static final String NOT_IMPLEMENTED = "Not implemented";
1540
1541  // Default TTL - FOREVER
1542  public static final long DEFAULT_SNAPSHOT_TTL = 0;
1543
1544  // User defined Default TTL config key
1545  public static final String DEFAULT_SNAPSHOT_TTL_CONFIG_KEY = "hbase.master.snapshot.ttl";
1546
1547  // Regions Recovery based on high storeFileRefCount threshold value
1548  public static final String STORE_FILE_REF_COUNT_THRESHOLD =
1549    "hbase.regions.recovery.store.file.ref.count";
1550
1551  // default -1 indicates there is no threshold on high storeRefCount
1552  public static final int DEFAULT_STORE_FILE_REF_COUNT_THRESHOLD = -1;
1553
1554  public static final String REGIONS_RECOVERY_INTERVAL =
1555    "hbase.master.regions.recovery.check.interval";
1556
1557  public static final int DEFAULT_REGIONS_RECOVERY_INTERVAL = 1200 * 1000; // Default 20 min
1558
1559  /**
1560   * Configurations for master executor services.
1561   */
1562  public static final String MASTER_OPEN_REGION_THREADS =
1563      "hbase.master.executor.openregion.threads";
1564  public static final int MASTER_OPEN_REGION_THREADS_DEFAULT = 5;
1565
1566  public static final String MASTER_CLOSE_REGION_THREADS =
1567      "hbase.master.executor.closeregion.threads";
1568  public static final int MASTER_CLOSE_REGION_THREADS_DEFAULT = 5;
1569
1570  public static final String MASTER_SERVER_OPERATIONS_THREADS =
1571      "hbase.master.executor.serverops.threads";
1572  public static final int MASTER_SERVER_OPERATIONS_THREADS_DEFAULT = 5;
1573
1574  /**
1575   * Number of threads used to dispatch merge operations to the regionservers.
1576   */
1577  public static final String MASTER_MERGE_DISPATCH_THREADS =
1578      "hbase.master.executor.merge.dispatch.threads";
1579  public static final int MASTER_MERGE_DISPATCH_THREADS_DEFAULT = 2;
1580
1581  public static final String MASTER_META_SERVER_OPERATIONS_THREADS =
1582      "hbase.master.executor.meta.serverops.threads";
1583  public static final int MASTER_META_SERVER_OPERATIONS_THREADS_DEFAULT = 5;
1584
1585  public static final String MASTER_LOG_REPLAY_OPS_THREADS =
1586      "hbase.master.executor.logreplayops.threads";
1587  public static final int MASTER_LOG_REPLAY_OPS_THREADS_DEFAULT = 10;
1588
1589  public static final int DEFAULT_SLOW_LOG_RING_BUFFER_SIZE = 256;
1590
1591  public static final String SLOW_LOG_BUFFER_ENABLED_KEY =
1592    "hbase.regionserver.slowlog.buffer.enabled";
1593  public static final boolean DEFAULT_ONLINE_LOG_PROVIDER_ENABLED = false;
1594
1595  /** The slowlog info family as a string*/
1596  private static final String SLOWLOG_INFO_FAMILY_STR = "info";
1597
1598  /** The slowlog info family */
1599  public static final byte [] SLOWLOG_INFO_FAMILY = Bytes.toBytes(SLOWLOG_INFO_FAMILY_STR);
1600
1601  public static final String SLOW_LOG_SYS_TABLE_ENABLED_KEY =
1602    "hbase.regionserver.slowlog.systable.enabled";
1603  public static final boolean DEFAULT_SLOW_LOG_SYS_TABLE_ENABLED_KEY = false;
1604
1605  /**
1606   * Number of rows in a batch operation above which a warning will be logged.
1607   */
1608  public static final String BATCH_ROWS_THRESHOLD_NAME = "hbase.rpc.rows.warning.threshold";
1609
1610  /**
1611   * Default value of {@link #BATCH_ROWS_THRESHOLD_NAME}
1612   */
1613  public static final int BATCH_ROWS_THRESHOLD_DEFAULT = 5000;
1614
1615  private HConstants() {
1616    // Can't be instantiated with this ctor.
1617  }
1618}