HBase version of Hadoop's Configured class that doesn't initialize the configuration via BaseConfigurable.setConf(Configuration) in the constructor, but only sets the configuration through the BaseConfigurable.setConf(Configuration) method

Implementer can return a CellScanner over its Cell content.

The identifier for this cluster.

Thrown by operations requiring coordination state access or manipulation when internal error within coordination engine (or other internal implementation) occurs.

Creates instance of CoordinatedStateManager based on configuration.

modifyTable op for replacing the table descriptor

An interface for an application-specific lock.

ScheduledThreadPoolExecutor that will add some jitter to the RunnableScheduledFuture.getDelay.

The field or the parameter to which this annotation can be applied only when it holds mutations for hbase:meta table.

An extension of the KeyValue where the tags length is always 0

The listener interface for receiving region state events.

An immutable class which contains a static method for handling org.apache.hadoop.ipc.RemoteException exceptions.

State of a WAL log split during distributed splitting.

Helper class for table state management for operations running inside RegionServer or HMaster.

This can be used when a Cell has to change with addition/removal of one or more tags.

Class servers two purposes: 1.

Deprecated. 

Marked as audience Private as of 1.2.0.

Marked as audience Private as of 1.2.0.

Deprecated. 

Returns whether or not the given name should be interpreted as a group principal.

Sets the given seqId to the cell.

A summation of this chore in human readable format.

INTERNAL Private constructor used internally creating table descriptors for catalog tables, hbase:meta and -ROOT-.

This constructor is for test only.

Utility class to handle the removal of HFiles (or the respective StoreFiles) for a HRegion from the FileSystem.

Example class for how to use the table archiving coordinated via zookeeper

A Doclet that only includes class-level elements that are annotated with InterfaceAudience.Public.

A Get, Put, Increment, Append, or Delete associated with it's region.

Used to communicate with a single HBase table similar to HTable but meant for batched, potentially asynchronous puts.

A client scanner for a region opened for read-only on the client side.

Configuration parameters for the connection.

Connection to an HTable from within a Coprocessor.

Helper callable for internal use when you just want to override a single method of a RetryingCallable.

HBaseAdmin is no longer a client API.

This class makes it convenient for one to execute a command in the context of a HConnection instance based on the given Configuration.

An implementation of Table.

Deprecated. 

A cache implementation for region locations from meta.

This class is for maintaining the various connection statistics and publishing them through the metrics interfaces.

A container for Result objects, grouped by regionName.

NonceGenerator interface.

This class is used to unify HTable calls with AsyncProcess Framework.

Similar to RegionServerCallable but for the AdminService interface.

Utility methods which contain the logic for regions and replicas.

A completion service for the RpcRetryingCallerFactory.

Datastructure that allows adding more info around Throwable incident.

A reversed client scanner which support backward scanning

Runs an rpc'ing RetryingCallable.

Caller that goes to replica if the primary region does no answer within a configurable timeout.

Used to separate the row constructing logic.

Parent interface for an object to get updates about per-region statistics.

This expects that the underlying arrays won't change.

Deprecated. 

Deprecated. 

Create a new RetriesExhaustedException from the list of prior failures.

Track the statistics for a single region

Client proxy for SecureBulkLoadProtocol used in conjunction with SecureBulkLoadEndpoint

Deprecated. 

Static wrapper class for the ArraySearcherPool.

Extends PtCell and manipulates its protected fields.

As the PrefixTreeArrayScanner moves through the tree bytes, it changes the values in the fields of this class so that Cell logic can be applied, but without allocating new memory for every Cell iterated through.

Position one of these appropriately in the data block and you can call its methods to retrieve the family or qualifier at the current position.

Given a block and its blockMeta, this will decode the timestamp for the i-th Cell in the block.

This is the primary class for converting a CellOutputStream into an encoded byte[].

Takes the tokenized family or qualifier data and flattens it into a stream of bytes.

Specifies the type of columnnode writer.

Most of the complexity of the PrefixTree is contained in the "row section".

Data structure used in the first stage of PrefixTree encoding: accepts a sorted stream of ByteRanges splits them into a set of tokens, each held by a TokenizerNode connects the TokenizerNodes via standard java references keeps a pool of TokenizerNodes and a reusable byte[] for holding all token content

Warning: currently unused, but code is valid.

Methods for seeking to a random Cell inside a sorted collection of cells.

Every class that wants to observe changes in Configuration properties, must implement interface (and also, register itself with the ConfigurationManager object.

Apply a Constraint (in traditional database terminology) to a HTable.

Processes multiple Constraints on a given table.

Coordinated operations for close region handlers.

Coordination operations for region merge transaction.

Coordinated operations for SplitLogWorker and WALSplitterHandler Important methods for SplitLogWorker:
SplitLogWorkerCoordination.isReady() called from SplitLogWorker.run() to check whether the coordination is ready to supply the tasks
SplitLogWorkerCoordination.taskLoop() loop for new tasks until the worker is stopped
SplitLogWorkerCoordination.isStop() a flag indicates whether worker should finish
SplitLogWorkerCoordination.registerListener() called from SplitLogWorker.run() and could register listener for external changes in coordination (if required)
SplitLogWorkerCoordination.endTask(SplitLogTask, AtomicLong, SplitTaskDetails) notify coordination engine that

ZK-based implementation of CloseRegionCoordination.

ZooKeeper based implementation of SplitLogManagerCoordination

Defines how value for specific column is interpreted and provides utility methods like compare, add, multiply etc for them.

Utility class for tracking metrics for various types of coprocessors.

Used to gracefully handle fallback to deprecated methods when we evolve coprocessor APIs.

The ForeignExceptionListener is an interface for objects that can receive a ForeignException.

Time a given process/operation and report a failure if the elapsed time exceeds the max allowed time.

Failed deserialization.

Exception thrown when an illegal argument is passed to a function/procedure.

Subclass if the server knows the region is now on another server.

Exception thrown when a blocking operation times out.

List of all HBase event handler types.

The following is a list of all executor types, both those that run in the master and those that run in the regionserver.

Base class for FilterList.

FilterListWithOR represents an ordered list of filters which will be evaluated with an OR operator.

Represents a filter that's filtering the metric Records.

Information about a field.

Represents the type of a FieldValue.

Represents a display mode in the top screen.

Implementation for ModeStrategy for Region Mode.

Utility class for calculating request counts per second.

This dispatches key presses and timers to the current ScreenView.

The screen where we can change the displayed fields, the sort key and the order of the fields.

The presentation logic for the help screen.

The screen where we can choose the Mode in the top screen.

The filter display mode in the top screen.

The presentation logic for the input mode.

The presentation logic for the message mode.

Utility class for paging for the metrics.

The data and business logic for the top screen.

The screen that provides a dynamic real-time view for the HBase metrics.

Terminal color definitions.

Represents the user pressing a key on the keyboard.

The interface responsible for printing to the terminal.

Utility class for escape sequences.

Represents a buffer of the terminal screen for double-buffering.

The implementation of the TerminalPrinter interface.

Statics to get access to Http related configuration.

Create a Jetty embedded server to answer http requests.

Our own implementation of ByteArrayOutputStream where all methods are NOT synchronized and supports writing ByteBuffer directly to it.

Accepts a stream of Cells.

The FileLink is a sort of hardlink, that allows access to a file given a set of locations.

Implementations can be asked for an estimate of their size in bytes.

Copied from guava source code v15 (LimitedInputStream) Guava deprecated LimitInputStream in v14 and removed it in v15.

A CellScanner that knows its size in memory in bytes.

WALLink describes a link to a WAL.

Fixes an inefficiency in Hadoop's Gzip codec, allowing to reuse compression streams.

Just copy data, do not do any kind of compression.

Compress using: - store size of common prefix - save column family once, it is same within HFile - use integer compression for key, value and prefix (7-bit encoding) - use bits to avoid duplication key length, value length and type if it same as previous - store in 3 bits length of timestamp field - allow diff in timestamp instead of actual value Format: - 1 byte: flag - 1-5 bytes: key length (only if FLAG_SAME_KEY_LENGTH is not set in flag) - 1-5 bytes: value length (only if FLAG_SAME_VALUE_LENGTH is not set in flag) - 1-5 bytes: prefix length - ...

Internal error which indicates a bug in a data block encoding algorithm.

Encoder similar to DiffKeyDeltaEncoder but supposedly faster.

A default implementation of HFileBlockDecodingContext.

An encoding context that is created by a writer's encoder, and is shared across the writer's whole lifetime.

Compress key by storing size of common prefix with previous KeyValue and storing raw size of rest.

Common functionality needed by all versions of HFile writers.

Cache Key for use with implementations of BlockCache

Various types of HFile blocks.

Interface for a deserializer.

Stores all of the cache objects and configuration for a single HFile.

Class that implements cache metrics.

CombinedBlockCache is an abstraction layer that combines LruBlockCache and BucketCache.

The HFile has a fixed trailer which contains offsets to other variable parts of the file.

Reads HFile version 2 blocks to HFiles and via Cacheable Interface to caches.

This carries the information on some of the meta data about the HFile.

Controls what kind of data block encoding is used.

HFile reader for version 2.

A scanner allows you to position yourself within a HFile and scan through it.

HFile writer for version 3.

Thrown when an invalid HFile format is detected

Represents an entry in the LruBlockCache.

Class to store blocks into memcached.

BlockCache which is resizable.

Thrown by BucketAllocator

Class that implements cache metrics for bucket cache.

A memory-bound queue that will grow until an element brings total size larger than maxSize.

IO engine that stores data to a file on the local file system.

A class implementing PersistentIOEngine interface supports persistent and file integrity verify for BucketCache

Adaptive LIFO blocking queue utilizing CoDel algorithm to prevent queue overloading.

Does RPC against a cluster.

Utilities for handling coprocessor service calls.

A class to manage a list of servers that failed recently.

Optionally carries Cells across the proxy/service interface down into ipc.

An interface for calling out of RPC for error conditions.

Provides clients with an RPC connection to call coprocessor endpoint Services against a given region server.

Interface for RpcClient implementations so ConnectionManager can handle it.

Factory to create a HBaseRpcController.

Used for server-side protobuf RPC service invocations.

Utility methods to interact with a job.

A callable object that invokes the corresponding action that needs to be taken for assignment of a region in transition.

Manages and performs region assignment.

Base class used bulk assigning and unassigning regions.

A janitor for the catalog tables.

Class to hold dead servers list and utility querying dead server list.

Provides the coprocessor framework and environment for master oriented operations.

This class abstracts a bunch of operations the HMaster needs to interact with the underlying file system, including splitting log files, checking file system status, etc.

Services Master supplies

Hadoop2 implementation of MetricsMasterSource.

Hadoop2 implementation of MetricsMasterSource.

Wrapper over the rack resolution utility in Hadoop.

State of a Region while undergoing transitions.

Region state accountant.

Get notification of server registration events.

Used internally for reading meta and constructing datastructures that are then queried, for things like regions to regionservers, table to regions, etc.

Distributes the task of log splitting to the available region servers.

Keeps track of the batch of tasks submitted together by a caller in splitLogDistributed().

A null implementation

This is a helper class used to manage the namespace metadata that is stored in TableName.NAMESPACE_TABLE_NAME It also mirrors updates to the ZK store by forwarding updates to ZKNamespaceManager

Chore that will feed the balancer the cluster status.

This class contains the mapping information between each region and its favored region server list.

Base class for the log cleaning function inside the master.

The thread pool used for scan directories

This Chore, every time it runs, will clear the HFiles in the hfile archive folder that are deletable for each HFile cleaner in the chain.

A cleaner that cleans replication locks on zk which is locked by dead region servers

Chore that will clean the replication queues belonging to the peer which does not exist.

Handler to create a table.

Handles MERGE regions request on master: move the regions together(on the same regionserver) and send MERGE RPC to regionserver.

Handles OPENED region event on Master.

Implementors tote an HRegionInfo instance.

Normalization plan to merge regions (smallest region in the table with its smallest neighbor).

Performs "normalization" of regions on the cluster, making sure that suboptimal choice of split keys doesn't leave cluster in a situation when some regions are substantially larger than others for considerable amount of time.

Factory to create instance of RegionNormalizer as configured.

Normalization plan to split region.

The procedure to create a new namespace.

The procedure to delete a column family from an existing table.

ProcedureRunnableSet for the Master Procedures.

The procedure to modify a column family from an existing table.

Helper to synchronously wait on conditions.

Procedures that handle servers -- e.g.

Take a snapshot of a disabled table.

General snapshot verification on the master.

Intelligently keep track of all the files for all the snapshots.

Helpers to create interned metrics info

HBase Metrics are grouped in different MetricRegistry'ies.

A statictical sample of histogram values.

Snapshot the current values in the Histogram

Dropwizard metrics implementation of Meter.

Custom histogram implementation based on FastLongHistogram.

Custom implementation of Timer.

A size-bounded repository of alerts, which are kept in a linked list.

A MonitoredTask implementation designed for use with RPC Handlers handling frequent, short duration tasks.

A globally-barriered distributed procedure.

RPCs for the coordinator to run a barriered procedure with subprocedures executed at distributed members.

Provides the common setup framework and runtime services for globally barriered procedure invocation from HBase services.

This is the notification interface for Procedures that encapsulates message passing from members to a coordinator.

Task builder to build instances of a ProcedureMember's Subprocedures.

ZooKeeper based controller for a procedure member.

Base Procedure class responsible to handle the Procedure Metadata e.g.

Special procedure used as a chore.

Simple runqueue for the procedures

A RemoteProcedureException is an exception from another thread or process.

Procedure described by a series of steps.

Called by the ProcedureExecutor to notify that one of the sub-procedures has completed.

Helper to convert the protobuf procedure.

Internal method called by the ProcedureExecutor that starts the user-level code execute().

Called by the ProcedureExecutor on procedure-load to restore the latch state

Called by the ProcedureExecutor on procedure-load to restore the latch state

Called by the ProcedureExecutor to assign the ID to the newly created procedure.

Called on store load to initialize the Procedure internals after the creation/deserialization.

Keeps track of live procedures.

Describes a WAL File

WAL implementation of the ProcedureStore.

Helper utility to build protocol buffer responses, or retrieve data from protocol buffer responses.

Generic quota exceeded exception for invalid settings

Interface that allows to check the quota available for an operation.

Internal interface used to interact with the user/table quota.

In-Memory state of table or namespace quotas

Helper class to interact with the quota table

Region Server Quota Manager.

In-Memory state of the user quotas

Reads special method annotations and table names to figure a priority for use by QoS facility in ipc; e.g: rpcs to hbase:meta get priority.

If set of MapFile.Readers in Store change, implementors are notified.

A chore service that periodically cleans up the compacted files when there are no active readers using those compacted files and also helps in clearing the block cache with these compacted file entries

Compact region on request and then run split if appropriate

HBASE-15400 This store engine allows us to store data in date tiered layout with exponential sizing so that the more recent data has more granularity.

Default implementation of StoreFlusher.

A custom RegionSplitPolicy implementing a SplitPolicy that groups rows by a prefix of the row-key with a delimiter.

A FlushPolicy that always flushes all stores for a given region.

Request a flush.

Manages tuning of Heap memory using HeapMemoryTuner.

A memstore-local allocation buffer.

View to an on-disk Region.

A Store holds a column family in a Region.

A custom RegionSplitPolicy implementing a SplitPolicy that groups rows by a prefix of the row-key This ensures that a region is not split "inside" a prefix of a row key.

Scanner that returns the next KeyValue.

LeaseListener is an interface meant to be implemented by users of the Leases class.

Runs periodically to determine if the WAL should be rolled.

The MemStore holds in-memory modifications to the Store.

A memstore-local allocation buffer.

This is the glue between the HRegion and whatever hadoop shim layer is loaded (hbase-hadoop1-compat or hbase-hadoop2-compat).

This class is for maintaining the various regionserver statistics and publishing them through the metrics interfaces.

Hadoop2 implementation of MetricsRegionServerSource.

Query Per Second for each table in a RegionServer.

Manages the read/write consistency.

A "non-lazy" scanner which always does a real seek operation.

An implementation of HeapMemoryTuner which is not doing any tuning activity but just allows to continue with old style fixed proportions.

Captures operation metrics by table.

A sink for a replication stream has to expose this service.

ReversedKeyValueHeap is used for supporting reversed scanning.

Implements the regionserver RPC services.

Immutable information for scans over a store.

Interface which abstracts implementations on log sequenceId assignment

Manage regionserver shutdown hooks.

StoreEngine is a factory that can create the objects necessary for HStore to operate.

Manages the store files and basic metadata about that that determines the logical structure (e.g.

Scanner scans both the memstore and the Store.

Base class for cell sink that separates the provided cells into multiple files for stripe compaction.

Stripe implementation of StoreFileManager.

Stores minimum and maximum timestamp values, it is [minimumTimestamp, maximumTimestamp] in interval notation.

Compaction configuration for a particular instance of HStore.

A compaction policy determines how to select files for compaction, how to compact them, and how to generate the compacted files.

Base class for compaction window implementation.

A compactor is a compaction algorithm associated a given policy.

This compactor will generate StoreFile for different time ranges.

Class to pick which files if any to compact together.

An abstract compaction policy that select files on seq id order.

This is the placeholder for stripe compactor.

Handles closing of a region on a region server.

Handles opening of a high priority region on a region server.

Handler to seek storefiles in parallel.

Handles log splitting a wal

Query matcher for compaction.