All Classes and Interfaces
Class
Description
Interface to support the aborting of a given server or client.
An abstract implementation of the ByteRange API
Helper class for custom client scanners.
Base class for unassigning table regions.
Decorates EncodedSeeker with a
HFileBlockDecodingContextTypical base class for file status filter.
Implementation of
WAL to go against FileSystem; i.e.Base class of a WAL Provider that returns a single thread safe WAL that writes to Hadoop FS.
Comparator used to compare WAL files together based on their start time.
A utility class that encapsulates SASL logic for RPC client.
Common base class used for HBase command-line tools.
An abstract class, which implements the behaviour shared by all concrete memstore instances.
Base class for cell sink that separates the provided cells into multiple files.
Base class for implementing a Compactor which will generate multiple output files after
compaction.
Base class for replication peer related procedures which do not need to hold locks(for most of
the sub procedures).
The base class for all replication peer related procedure.
Extends the basic
SimpleByteRange implementation with position support.Base class for Protobuf log writer.
Base class for reading protobuf based wal reader
This class is used to extend AP to process single action request, like delete, get etc.
Base class for rpc based connection registry implementation.
For describing the actual asynchronous rpc call.
Provides the basics for a RpcClient implementation like configuration and Logging.
Blocking rpc channel that goes via hbase rpc.
Async rpc channel that goes via hbase rpc.
Base implementation of
SaslClientAuthenticationProvider.An abstract class for
ScreenView that has the common useful methods and the default
implementations for the abstract methods.Base class for all the Namespace procedures that want to use a StateMachineProcedure.
Base class for all the Region procedures that want to use a StateMachine.
Base class for all the Table procedures that want to use a StateMachineProcedure.
Abstract implementation for
SpaceViolationPolicyEnforcement.Base class for a WAL Provider.
Runs periodically to determine if the WAL should be rolled.
A temporary user class to instantiate User instance based on the name and groups.
Utility client for doing access control admin operations.
NOTE: for internal use only by AccessController implementation
Provides basic authorization checks for data access and administrative operations.
Exception thrown by access-related methods.
A Get, Put, Increment, Append, or Delete associated with it's region.
Handles everything on master-side related to master election.
A class to ease dealing with tables that have and do not have violation policies being enforced.
Adaptive LIFO blocking queue utilizing CoDel algorithm to prevent queue overloading.
Adaptive is a heuristic that chooses whether to apply data compaction or not based on the level
of redundancy in the data.
The procedure for adding a new replication peer.
An immutable type to hold a hostname and port combo, like an Endpoint or
java.net.InetSocketAddress (but without danger of our calling resolve -- we do NOT want a resolve
happening every time we want to hold a hostname and port combo).
Utility for network addresses, resolving and naming.
Interface for AddressSelectionCondition to check if address is acceptable
The administrative API for HBase.
General servlet which is admin-authorized.
The
Admin implementation which is based on an AsyncAdmin.This is the low level API for asynchronous scan.
Used to suspend or stop a scan, or get a scan cursor if available.
Used to resume a scan.
AES-128, provided by the JCE
Snapshot of block cache age in cache.
A ScanResultCache that may return partial result.
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.
Performs Append operations on a single row.
This is a
Tag implementation in which value is backed by an on heap byte array.The AssignmentManager is the coordinator for region assign/unassign operations.
Utility for this assignment package only.
Helper class that is used by RegionPlacementMaintainer to print information for favored nodes
Deprecated.
Do not use any more.
Handles opening of a region on a region server.
The asynchronous administrative API for HBase.
For creating
AsyncAdmin.Base class for all asynchronous admin builders.
Additional Asynchronous Admin capabilities for clients.
Retry caller for batch.
Used to communicate with a single HBase table in batches.
For creating
AsyncBufferedMutator.The implementation of
AsyncBufferedMutatorBuilder.The implementation of
AsyncBufferedMutator.A simple example shows how to use asynchronous client.
The asynchronous client scanner implementation.
The asynchronous connection for internal usage.
The implementation of AsyncClusterConnection.
The asynchronous version of Connection.
Timeout configs.
The implementation of AsyncConnection.
Interface for asynchronous filesystem output stream.
Helper class for creating AsyncFSOutput.
An asynchronous implementation of FSWAL.
A WAL provider that use
AsyncFSWAL.Just a wrapper of
RawAsyncHBaseAdmin.Retry caller for a request call to master.
The asynchronous locator for meta region.
The asynchronous locator for regions other than meta.
AsyncWriter for protobuf-based WAL.
Cache of RegionLocations for use by
AsyncNonMetaRegionLocator.The asynchronous region locator.
Helper class for asynchronous region locator.
For replicating edits to secondary replicas.
A simple wrapper of the
AdminProtos.AdminService for a region server, which returns a
CompletableFuture.Factory to create an AsyncRpcRetryCaller.
Retry caller for scanning a region.
Retry caller for a request call to region server.
Retry caller for a single request, such as get, put, delete, etc.
The interface for asynchronous version of Table.
Deprecated.
Since 3.0.0, will be removed in 4.0.0.
Deprecated.
Since 3.0.0, will be removed in 4.0.0.
The callback when we want to execute a coprocessor call on a range of regions.
Helper class for sending coprocessorService request that executes a coprocessor call on regions
which are covered by a range.
Some coprocessors may support the idea of "partial results." If for some reason a coprocessor
cannot return all results for a given region in a single response, the client side can be
designed to recognize this and continuing requesting more results until they are completely
accumulated in the client.
For creating
AsyncTable.Base class for all asynchronous table builders.
Just a wrapper of
RawAsyncTableImpl.The asynchronous version of RegionLocator.
The implementation of AsyncRegionLocator.
The
ResultScanner implementation for RawAsyncTableImpl.Utilities related to atomic operations.
Wrapper around a SaslServer which provides the last user attempting to authenticate via SASL, if
the server/mechanism allow figuring that out.
The attributes of text in the terminal.
This class is copied from Hadoop.
Represents a secret key used for signing and verifying authentication tokens by
AuthenticationTokenSecretManager.Represents the identity information stored in an HBase authentication token.
Manages an internal list of secret keys used to sign new authentication tokens as they are
generated, and to valid existing tokens used for authentication.
Performs authorization checks for a given user's assigned permissions.
Cache of permissions, it is thread safe.
Authentication method
This class contains visibility labels associated with a Scan/Get deciding which all labeled data
current scan/get can access.
Represents the result of an authorization check for logging and error reporting.
Deprecated.
since 2.2.0, to be marked as
InterfaceAudience.Private in 4.0.0.This limiter will refill resources at every TimeUnit/resources interval.
Helper class that allows to create and manipulate an AvlTree.
Helper class that allows to create and manipulate a linked list of AvlLinkedNodes
The AvlTree allows to lookup an object using a custom key.
This class extends the AvlNode and adds two links that will be used in conjunction with the
AvlIterableList class.
This class represent a node that will be used in an AvlTree.
Visitor that allows to traverse a set of AvlNodes.
Helper class that allows to create and manipulate an AVL Tree
Iterator for the AvlTree
The administrative API for HBase Backup.
General backup commands, options and usage messages
Backup copy job is a part of a backup process.
Command-line entry point for backup operation
Backup exception
Implementation of a file cleaner that checks if an hfile is still referenced by backup before
deleting it from hfile archive directory.
An object to encapsulate the information for each backup session
BackupPhase - phases of an ACTIVE backup session (running), when state of a backup session is
BackupState.RUNNING
Backup session states
Implementation of a log cleaner that checks if a log is still scheduled for incremental backup
before deleting it when its TTL is over.
Handles backup requests, creates backup info records in backup system table to keep track of
backup sessions, dispatches backup request.
Backup manifest contains all the meta data of a backup image.
Backup image, the dependency graph is made up by series of backup images BackupImage contains
all the relevant information to restore the backup and is used during restore operation
Backup merge operation job interface.
An Observer to facilitate backup operations
POJO class for backup request
BackupRestoreConstants holds a bunch of HBase Backup and Restore constants
Factory implementation for backup/restore related jobs
Backup set is a named group of HBase tables, which are managed together by Backup/Restore
framework.
This class provides API to access backup system table
Backup system table schema:
Backup system table schema:
Backup related information encapsulated for a table.
A collection for methods used by multiple classes to backup HBase tables.
An action to move or swap a region
An
RpcExecutor that will balance requests evenly across all its queues, but still remains
efficient with a single queue via an inlinable queue balancing mechanism.Chore that will call HMaster.balance
HMaster.balance() when
needed.An efficient array based implementation similar to ClusterState for keeping the status of the
cluster in terms of region assignment and distribution.
History of balancer decisions taken for region movements.
Balancer decision details that would be passed on to ring buffer for history
In-memory Queue service provider for Balancer Decision events
Encapsulates options for executing a run of the Balancer.
Builder for constructing a
BalanceRequestResponse returned from a balancer invocation
Used in HMaster to build a
BalanceResponse for returning results of a balance
invocation to callersWrapper class for the few fields required by the
StochasticLoadBalancer from the full
RegionMetrics.History of detail information that balancer movements was rejected
Balancer rejection details that would be passed on to ring buffer for history
In-memory Queue service provider for Balancer Rejection events
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) methodBase class to use when actually implementing a
Constraint.Base implementation for
Codec.Decoder.TODO javadoc
Encapsulation of the environment of each coprocessor
Base class for file cleaners which allows subclasses to implement a simple isFileDeletable method
(which used to be the FileCleanerDelegate contract).
Base class for the hfile cleaning function inside the master.
The base class for load balancers.
Base class for the log cleaning function inside the master.
A Base implementation for
ReplicationEndpoints.BaseSource for dynamic metrics to announce to Metrics2.
Hadoop 2 implementation of BaseSource (using metrics2 framework).
Base class for time to live file cleaner.
Basic strategy chooses between two actions: flattening a segment or merging indices of all
segments in the pipeline.
A collection of interfaces and utilities used for interacting with custom RPC interfaces exposed
by Coprocessors.
Defines a unit of work to be executed.
Defines a generic callback to be triggered for each
Batch.Call.call(Object) result.A scan result cache for batched scan, i.e,
scan.getBatch() > 0 && !scan.getAllowPartialResults().An implementation of the
Terminal interface for batch mode.An implementation of the
TerminalPrinter interface for batch mode.Implementation of
FileKeyStoreLoader that loads from BCKFS files.ColumnInterpreter for doing Aggregation's with BigDecimal columns.
A BigDecimal comparator which numerical compares against the specified byte array
A binary comparator which lexicographically compares against the specified byte array using
Bytes.compareTo(byte[], byte[]).A comparator which compares against a specified byte array, but only compares specific portion of
the byte array.
A comparator which compares against a specified byte array, but only compares up to the length of
this byte array.
A bit comparator which performs the specified bitwise operation on each of the bytes with the
specified byte array.
Bit operators.
Deprecated.
Since 2.3.0, will be removed in 4.0.0.
Block cache interface.
Enum of all built in external block caches.
Cache Key for use with implementations of
BlockCacheIterator over an array of BlockCache CachedBlocks.
Utilty for aggregating counts in CachedBlocks and toString/toJSON CachedBlocks and BlockCaches.
Little data structure to hold counts for a file.
Use one of these to keep a running account of cached blocks by file.
Allows for defining different compression rate predicates on its implementing classes.
Simple
RpcCallback implementation providing a Future-like
BlockingRpcCallback.get() method, which will block util the instance's
BlockingRpcCallback.run(Object) method has been called.Does RPC against a cluster.
Thread that reads responses and notifies callers.
Various types of HFile blocks.
BlockWithScanInfo is wrapper class for HFileBlock with other attributes.
The bloom context that is used by the StorefileWriter to add the bloom details per cell
Implements a Bloom filter, as defined by Bloom in 1970.
Common methods Bloom filter methods required at read and write time.
The basic building block for the
CompoundBloomFilterHandles Bloom filter initialization based on configuration and serialized metadata in the reader
and writer of
HStoreFile.Utility methods related to BloomFilters
Specifies methods needed to add elements to a Bloom filter and serialize the resulting Bloom
filter as a sequence of bytes.
Store a boolean state.
Manage the bootstrap node list at region server side.
A completion service, close to the one available in the JDK 1.7 However, this ones keeps the list
of the future, and allows to cancel them all.
Used for
BoundedRecoveredEditsOutputSink.A WAL grouping strategy that limits the number of wal groups to
"hbase.wal.regiongrouping.numgroups".
A generic bounded blocking Priority-Queue.
Class that manages the output streams from the log splitting process.
A WALSplitter sink that outputs
HFiles.This Chore, every time it runs, will clear the unsused HFiles in the data folder.
Hadoop brotli codec implemented with Brotli4j
Hadoop compressor glue for Brotli4j
Hadoop decompressor glue for Brotli4j
This class is used to allocate a block with specified size and free the block when evicting.
Statistics to give a glimpse into the distribution of BucketCache objects.
Thrown by
BucketAllocatorBucketCache uses
BucketAllocator to allocate/free blocks, and uses BucketCache#ramCache
and BucketCache#backingMap in order to determine if a given element is in the cache.Enum to represent the state of cache
Wrapped the delegate ConcurrentMap with maintaining its block's reference count.
Block Entry stored in the memory with key,data and so on
Class that implements cache metrics for bucket cache.
Item in cache.
We will expose the connection to upper layer before initialized, so we need to buffer the calls
passed in and write them out once the connection is established.
Chain of ByteBuffers.
Base class for all data block encoders that use a buffer.
Copies only the key part of the keybuffer by doing a deep copy and passes the seeker state
members for taking a clone.
Used to communicate with a single HBase table similar to
Table but meant for batched,
asynchronous puts.Listens for asynchronous exceptions on a
BufferedMutator.An example of using the
BufferedMutator interface.BufferedMutator implementation based on AsyncBufferedMutator.Parameters for instantiating a
BufferedMutator.Default implementation of
AuthenticationProviderSelector which can choose from the
authentication implementations which HBase provides out of the box: Simple, Kerberos, and
Delegation Token authentication.Base class for all Apache HBase, built-in
SaslAuthenticationProvider's to extend.Defines a protocol to delete data in bulk based on a scan.
The tool to let you load the output of
HFileOutputFormat into an existing table
programmatically.Represents an HFile waiting to be loaded.
The implementation for
BulkLoadHFiles, and also can be executed from command line as a
tool.Coprocessors implement this interface to observe and mediate bulk load operations.
This class represents a split policy which makes the split decision based on how busy a region
is.
Base class for byte array comparators
Our own implementation of ByteArrayOutputStream where all methods are NOT synchronized and
supports writing ByteBuffer directly to it.
Serialize a
byte[] using Bytes.toString().An abstract class that abstracts out as to how the byte buffers are used, either single or
multiple.
Functional interface for Channel read
ByteBuffAllocator is a nio ByteBuffer pool.
Defines the way the ByteBuffers are created
This class manages an array of ByteBuffers with a default size 4MB.
ByteBuffer based cell which has the chunkid at the 0th offset
This class is a server side extension to the
Cell interface.Not thread safe!
IO engine that stores data in memory using an array of ByteBuffers
ByteBufferArray.This is a key only Cell implementation which is identical to
KeyValue.KeyOnlyKeyValue
with respect to key serialization but have its data in the form of Byte buffer (onheap and
offheap).This Cell is an implementation of
ByteBufferExtendedCell where the data resides in off
heap/ on heap ByteBufferAn OutputStream which writes data into ByteBuffers.
Not thread safe!
This is a
Tag implementation in which value is backed by ByteBufferUtility functions for working with byte buffers, such as reading/writing variable-length long
numbers.
This interface marks a class to support writing ByteBuffers into it.
Our extension of DataOutputStream which implements ByteBufferWriter
When deal with OutputStream which is not ByteBufferWriter type, wrap it with this class.
Not thread safe!
Lightweight, reusable class for specifying ranges of byte[]'s.
Utility methods for working with
ByteRange.Utility class that handles byte arrays, conversions to/from other types, comparisons, hash code
generation, manufacturing keys for HashMaps or HashSets, and can be used as key in maps or trees.
Byte array comparator class.
Provides a lexicographical comparer implementation; either a Java implementation or a faster
implementation based on
Unsafe.A
Bytes.ByteArrayComparator that treats the empty array as the largest value.Similar to the ByteArrayOutputStream, with the exception that we can prepend an header.
Cacheable is an interface that allows for an object to be cached.
Interface for a deserializer.
This class is used to manage the identifiers for
CacheableDeserializer.Stores all of the cache objects and configuration for a single HFile.
Caches the cluster ID of the cluster.
A memory-bound queue that will grow until an element brings total size larger than maxSize.
Cached mob file.
Used to merge CacheEvictionStats.
Thrown by
BucketAllocator.allocateBlock(int) when cache is full for the requested sizeClass that implements cache metrics.
A call waiting for a value.
Client side call cancelled.
Returned to the clients when their request was discarded due to server being overloaded.
Exception indicating that the remote host making this IPC lost its IPC connection.
Used to tell netty handler the call is cancelled, timeout...
A BlockingQueue reports waiting time in queue and queue length to ThriftMetrics.
Returned to clients when their request was dropped because the call queue was too big to accept a
new call.
The request processing logic, which is usually executed in thread pools provided by an
RpcScheduler.Client-side call timeout
HBase Canary Tool for "canary monitoring" of a running HBase cluster.
A Monitor super-class can be extended by users
A monitor for region mode.
A monitor for regionserver mode
By RegionServer, for 'regionserver' mode.
Run a single RegionServer Task and then exit.
By Region, for 'region' mode.
Run a single Region Task and then exit.
Canary region mode-specific data structure which stores information about each region to be
scanned
Sink interface used by the canary to output information
Simple implementation of canary sink that allows plotting to a file or standard output.
Output for 'zookeeper' mode.
Run a single zookeeper Task and then exit.
Similar interface as
Progressable but returns a boolean to support
canceling the operation.Generates a candidate action to be applied to the cluster for cost function search
This is a marker interface that indicates if a compressor or decompressor type can support
reinitialization via reinit(Configuration conf).
Helper class for generating/parsing
"info" family cells in meta table.
A janitor for the catalog tables.
Compare HRegionInfos in a way that has split parents sort BEFORE their daughters.
Report made by ReportMakingVisitor
A Catalog replica selector decides which catalog replica to go for read requests when it is
configured as CatalogReplicaMode.LoadBalance.
Factory to create a
CatalogReplicaLoadBalanceSelector
CatalogReplicaLoadBalanceReplicaSimpleSelector implements a simple catalog replica load balancing
algorithm.
StaleLocationCacheEntry is the entry when a stale location is reported by an client.
There are two modes with catalog replica support.
The unit of storage in HBase consisting of the following fields:
Represents a single text cell of the terminal.
The valid types for user to build the cell.
CellArrayImmutableSegment extends the API supported by a
Segment, and
ImmutableSegment.CellArrayMap is a simple array of Cells and cannot be allocated off-heap.
Helper class for building cell block.
Use
CellBuilderFactory to get CellBuilder instance.Create a CellBuilder instance.
Used by
CellBuilderFactory and ExtendedCellBuilderFactory.CellChunkImmutableSegment extends the API supported by a
Segment, and
ImmutableSegment.CellChunkMap is an array of serialized representations of Cell (pointing to Chunks with full Cell
data) and can be allocated both off-heap and on-heap.
Basic Cell codec that just writes out all the individual elements of a Cell.
Basic Cell codec that just writes out all the individual elements of a Cell including the tags.
Comparator for comparing cells and has some specialized methods that allows comparing individual
cell components like row, family, qualifier and timestamp
Compare two HBase cells.
A job with a a map and reduce phase to count cells in a table.
Mapper that runs the count.
Counter enumeration to count the actual rows.
Facade to create Cells for HFileOutputFormat.
CellFlatMap stores a constant number of elements and is immutable after creation stage.
Extracts the byte for the hash calculation from the given cell
Representation of a cell.
Accepts a stream of Cells.
Implementer can return a CellScanner over its Cell content.
An interface for iterating through a sequence of cells.
Thrown if a cellscanner but no codec to encode it with.
Representation of a grouping of cells.
A sink of cells that allows appending cells to the Writers that implement it.
Emits sorted Cells.
Utility methods helpful for slinging
Cell instances.This contains a visibility expression which can be associated with a cell.
A
ChainWALEntryFilter for providing more flexible optionsA
WALEntryFilter which contains multiple filters and applies them in chain orderIf set of MapFile.Readers in Store change, implementors are notified.
An agent for executing destructive actions for ChaosMonkey.
Executes Command locally.
ChaosConstant holds a bunch of Choas-related Constants
Class used to start/stop Chaos related services (currently chaosagent)
ChaosUtils holds a bunch of useful functions like getting hostname and getting ZooKeeper quorum.
Used to perform CheckAndMutate operations.
A builder class for building a CheckAndMutate object.
Represents a result of a CheckAndMutate operation
Checksum types.
Utility methods to compute and validate checksums.
ChoreService is a service that can be used to schedule instances of
ScheduledChore to run
periodically while sharing threads.Custom ThreadFactory used with the ScheduledThreadPoolExecutor so that all the threads are
daemon threads, and thus, don't prevent the JVM from shutting down
A chunk of memory out of which allocations are sliced.
Does the management of memstoreLAB chunk creations.
Types of chunks, based on their sizes
A common interface for a cryptographic algorithm.
An CipherProvider contributes support for various cryptographic Ciphers.
Deprecated.
Use
AssignReplicationQueuesProcedure instead, kept only for keeping
compatibility.Utilities for class manipulation.
Base class loader that defines couple shared constants used by sub-classes.
Class for determining the "size" of a class, an attempt to calculate the actual bytes that an
object of this class will occupy in memory The core of this class is taken from the Derby project
MemoryLayout abstracts details about the JVM object layout.
UnsafeLayout uses Unsafe to guesstimate the object-layout related parameters like object header
sizes and oop sizes See HBASE-15950.
Abstract Cleaner that uses a chain of delegates to clean a directory of files
A wrapper around HttpClient which provides some useful function and semantics for interacting
with the REST gateway.
Configurable policy for the amount of time a client should wait for a new request to the server
when given the server load statistics.
Default backoff policy that doesn't create any backoff for the client, regardless of load
Client side rpc controller for coprocessor implementation.
The class that is able to determine some unique strings for the client, such as an IP address,
PID, and composite deterministic ID.
A helper class used to access the package private field in o.a.h.h.client package.
The (asynchronous) meta table accessor used at client side.
Implementations 'visit' a catalog table row but with close() at the end.
Collects all returned.
A
ClientMetaTableAccessor.Visitor that collects content out of passed Result.Implementations 'visit' a catalog table row.
Implementation for
ModeStrategy for client Mode.A client scanner for a region opened for read-only on the client side.
Class to help with dealing with a snapshot description on the client side.
Utility methods for obtaining authentication tokens, that do not require hbase-server.
Common Utility class for clients
Tracks the target znode(s) on server ZK cluster and synchronize them to client ZK cluster if
changed
Used to store the newest data which we want to sync to client zk.
This exception is thrown by the master when a region server clock skew is too high.
Check periodically to see if a system stop is requested
Procedure for close excess region replicas.
Handles closing of the meta region on a region server.
Handles closing of a region on a region server.
The remote procedure used to close a region.
Procedure for closing all regions for a table.
A list of 'host:port' addresses of HTTP servers operating as a single entity, for example
multiple redundant web service gateways.
The factory for creating
AsyncClusterConnection.The identifier for this cluster.
Fetch cluster id through special preamble header.
This is the cluster we want to balance.
Class used to hold the current state of the cluster and how balanced it is.
Filters out entries with our peerClusterId (i.e.
Metrics information on the HBase cluster.
Exposes a subset of fields from
ClusterMetrics.Kinds of ClusterMetrics
The root object exposing a subset of
ClusterMetrics.View and edit the current cluster schema.
Mixes in ClusterSchema and Service
Chore that will feed the balancer the cluster status.
A class that receives the cluster status, and provide it as a set of service to the client.
Class to be extended to manage a new dead server.
The interface to be implemented by a listener of a cluster status event.
Class to publish the cluster status to the client.
ClusterStatusPublisher.MulticastPublisher.HBaseDatagramChannelFactory<T extends org.apache.hbase.thirdparty.io.netty.channel.Channel>
Tracker on cluster settings up in zookeeper.
Encoder/Decoder for Cell.
Implementations should implicitly clean up any resources allocated when the Decoder/CellScanner
runs off the end of the cell block.
Call flush when done.
Thrown when problems in the codec whether setup or context.
Utility scanner that wraps a sortable collection and serves as a KeyValueScanner.
Terminal color definitions.
Simple wrapper for a byte buffer and a counter.
Simple filter that returns first N columns on row only.
An ColumnFamilyDescriptor contains information about a column family such as the number of
versions, compression settings, etc.
An ModifyableFamilyDescriptor contains information about a column family such as the number of
versions, compression settings, etc.
ColumnInterpreter<T,S,P extends org.apache.hbase.thirdparty.com.google.protobuf.Message,Q extends org.apache.hbase.thirdparty.com.google.protobuf.Message,R extends org.apache.hbase.thirdparty.com.google.protobuf.Message>
Defines how value for specific column is interpreted and provides utility methods like compare,
add, multiply etc for them.
A filter, based on the ColumnCountGetFilter, takes two arguments: limit and offset.
This filter is used for selecting only those keys with columns that matches a particular prefix.
This filter is used for selecting only those keys with columns that are between minColumn to
maxColumn.
Representation of a column family schema.
Implementing classes of this interface will be used for the tracking and enforcement of columns
and numbers of versions and timeToLive during the course of a Get or Scan operation.
Different from
SingleColumnValueFilter which returns an entire row when specified
condition is matched, ColumnValueFilter return the matched cell only.An
WALProvider.AsyncWriter wrapper which writes data to a set of WALProvider.AsyncWriter instances.CombinedBlockCache is an abstraction layer that combines
FirstLevelBlockCache and
BucketCache.Base class for combined wal writer implementations.
Represents a description of a command that we can execute in the top screen.
Utility methods for interacting with the underlying file system.
Helper exception for those cases where the place where we need to check a stream capability is
not where we have the needed context to explain the impact and mitigation for a lack.
Event handler that handles the removal and archival of the compacted hfiles
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 of these compacted file
entries.
A memstore implementation which supports in-memory compaction.
Types of indexes (part of immutable segments) to be used after flattening, compaction, or merge
are applied.
Compaction configuration for a particular instance of HStore.
This class holds all "physical" details necessary to run a compaction, and abstracts away the
details specific to a particular compaction.
Used to track compaction execution.
The compaction pipeline of a
CompactingMemStore, is a FIFO queue of segments.A compaction policy determines how to select files for compaction, how to compact them, and how
to generate the compacted files.
This class holds information relevant for tracking the progress of a compaction.
Coprocessors use this interface to get details about compaction.
Request a compaction.
This class holds all logical details necessary to run a compaction.
Query matcher for compaction.
POJO representing the compaction state
Input format that uses store files block location as input split locality.
Class responsible to execute the Compaction on the specified path.
Base class for compaction window implementation.
For creating compaction window.
A compactor is a compaction algorithm associated a given policy.
The sole reason this class exists is that java has no ref/out/pointer parameters.
Compact region on request and then run split if appropriate
Currently, there are only two compact types:
NORMAL means do store files compaction;
MOB means do mob files compaction.This is a generic filter to be used to filter by comparison.
Generic set of comparison operators.
Class that will create many instances of classes provided by the hbase-hadoop{1|2}-compat jars.
Factory for classes supplied by hadoop compatibility modules.
Internal cleaner that removes the completed procedure results after a TTL.
Hold the reference to a completed root procedure.
A scan result cache that only returns complete result.
The CompositeImmutableSegments is created as a collection of ImmutableSegments and supports the
interface of a single ImmutableSegments.
A Bloom filter implementation built on top of
BloomFilterChunk, encapsulating a set of fixed-size Bloom
filters written out at the time of HFile generation into
the data block stream, and loaded on demand at query time.Adds methods required for writing a compound Bloom filter to the data section of an
HFile to the CompoundBloomFilter class.A Bloom filter chunk enqueued for writing
Do a shallow merge of multiple KV configuration pools.
Compression related stuff.
Compression algorithms.
Context that holds the various dictionaries for compression in WAL.
Encapsulates the compression algorithm and its streams that we will use for value compression
in this WAL.
Stores the state of data block encoder at the beginning of new key.
Compression validation test.
A set of static functions for running our custom WAL compression/decompression.
A collection class that contains multiple sub-lists, which allows us to not copy lists.
Utility methods for dealing with Collections, including treating null collections as empty.
Thrown when a table has been modified concurrently
Maintains the set of all the classes which would like to get notified when the Configuration is
reloaded from the disk in the Online Configuration Change mechanism, which lets you update
certain configuration properties on-the-fly, without having to restart the cluster.
Every class that wants to observe changes in Configuration properties, must implement interface
(and also, register itself with the
ConfigurationManager.Utilities for storing more complex collection types in
Configuration instances.A servlet to print out the running configuration data.
A cluster connection encapsulating lower level individual connections to actual servers and a
connection to zookeeper.
A utility to store user specific HConnections in memory.
Thrown when the connection is closed
Thrown when the client believes that we are trying to communicate to has been repeatedly
unresponsive for a while.
Configuration parameters for the connection.
A non-instantiable class that manages creation of
Connections.This class holds the address and the user ticket, etc.
The connection implementation based on
AsyncConnection.Registry for meta information needed for connection setup to a HBase cluster.
Define the necessary method for carrying
ClientMetaService.The entry point for creating a
ConnectionRegistry.A class for creating
RpcClient and related stubs used by
AbstractRpcBasedConnectionRegistry.For creating different
ConnectionRegistry implementation.Construct
Span instances originating from the client side of a connection.Utility used by client connections.
Consistency defines the expected consistency level for an operation.
Common constants for org.apache.hadoop.hbase.rest
Thrift related constants
A
RegionSplitPolicy implementation which splits a region as soon as any of its store
files exceeds a maximum configurable size.Apply a
Constraint (in traditional database terminology) to a Table.Exception that a user defined constraint throws on failure of a
Put.Processes multiple
Constraints on a given table.Utilities for adding/removing constraints from a table.
Crypto context.
Implementations of this interface will keep and return to clients implementations of classes
providing API to execute coordinated operations.
Base interface for the 4 coprocessors - MasterCoprocessor, RegionCoprocessor,
RegionServerCoprocessor, and WALCoprocessor.
Lifecycle state of a given coprocessor instance.
Deprecated.
ClassLoader used to load classes for Coprocessor instances.
Helper class for coprocessor host when configuration changes.
CoprocessorDescriptor contains the details about how to build a coprocessor.
Used to build the
CoprocessorDescriptorCoprocessor environment state.
Thrown if a coprocessor encounters any exception.
Provides the common setup framework and runtime services for coprocessor invocation from HBase
services.
Environment priority comparator.
Implementations defined function to get an observer of type
O from a coprocessor of
type C.Deprecated.
Please stop using this class again, as it is too low level, which is part of the rpc
framework for HBase.
Utilities for handling coprocessor rpc service calls.
Simple
RpcCallback implementation providing a Future-like
CoprocessorRpcUtils.BlockingRpcCallback.get() method, which will block util the instance's
CoprocessorRpcUtils.BlockingRpcCallback.run(Object) method has been called.Deprecated.
Since 2.0.
This classloader implementation calls
ClassLoader.resolveClass(Class) method for every loaded
class.Master observer for restricting coprocessor assignments.
Just copy data, do not do any kind of compression.
A Map that keeps a sorted array in order to provide the concurrent map interface.
A tool for copying replication peer data across different replication peer storages.
Tool used to copy a table to another one which can be on a different setup.
Marker annotation that denotes Coprocessors that are core to HBase.
Exception thrown when the found snapshot info from the filesystem is not valid.
Deprecated.
Since 2.3.0, will be removed in 4.0.0.
This exception is thrown when attempts to read an HFile fail due to corruption or truncation
issues.
Class to be used for the subset of RegionLoad costs that should be treated as rates.
Base class the allows writing costs functions from rolling average of some number from
RegionLoad.
Base class of StochasticLoadBalancer's Cost Functions.
A mutable number optimized for high concurrency counting.
Custom implementation of
Counter using LongAdder.Compute the cost of total number of coprocessor requests The more unbalanced the higher the
computed cost will be.
The procedure to create a new namespace.
This is a command line class that will snapshot a given table.
AES encryption and decryption.
Helper class for providing integrity protection.
The default cipher provider.
CSLMImmutableSegment is an abstract class that extends the API supported by a
Segment,
and ImmutableSegment.Scan cursor to tell client where server is scanning
Scan.setNeedCursorResult(boolean)
Result.isCursor() Result.getCursor()A 2-d position in 'terminal space'.
Helper class for CP hooks to change max versions and TTL.
Thrown when a failed append or sync on a WAL.
Encoding of KeyValue.
An interface which enable to seek while underlying data is encoded.
Provide access to all data block encoding algorithms.
DataType is the base class for all HBase data types.HBASE-15181 This is a simple implementation of date-based tiered compaction similar to
Cassandra's for the following benefits:
Improve date-range-based scan by structuring store files in date-based tiered layout.
Reduce compaction overhead.
Improve TTL efficiency.
Perfect fit for the use cases that:
has mostly date-based data write and scan and a focus on the most recent data.
Out-of-order writes are handled gracefully.
This compactor will generate StoreFile for different time ranges.
class for cell sink that separates the provided cells into multiple files for date tiered
compaction.
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.
Class to hold dead servers list and utility querying dead server list.
A ByteBuffAllocator that rewrite the bytebuffers right after released.
Decryptors apply a cipher to an InputStream to recover plaintext.
The default cipher provider.
Compact passed set of files.
Default implementation of an environment edge.
The default implementation for the HeapMemoryTuner.
The MemStore holds in-memory modifications to the Store.
Compact passed set of files in the mob-enabled column family.
An implementation of the StoreFlusher.
This will load all the xml configuration files for the source cluster replication ID from user
configured replication configuration directory.
Default StoreEngine creates the default compactor, policy, and store file manager, or their
derivatives.
Default implementation of StoreFileManager.
The default implementation for store file tracker, where we do not persist the store file list,
and use listing when loading store files.
Default implementation of StoreFlusher.
The default implementation for
SpaceViolationPolicyEnforcement.This implementation creates tags by expanding expression using label ordinal.
This is an implementation for ScanLabelGenerator.
Vessel that carries a Procedure and a timeout.
Has a timeout.
Add a timeout to a Delay
Simple delegating controller for use with the
RpcControllerFactory to help override
standard behavior of a HBaseRpcController.An input stream that delegates all operations to another input stream.
A simple delegation for doing filtering on
InternalScanner.Users of the hbase.region.server.rpc.scheduler.factory.class customization config can return an
implementation which extends this class in order to minimize impact of breaking interface
changes.
Used to perform Delete operations on a single row.
The procedure to remove a namespace.
This interface is used for the tracking and enforcement of Deletes during the course of a Get or
Scan operation.
Returns codes for delete result.
A ZooKeeper watcher meant to detect deletions of ZNodes.
Deprecated.
since 3.0.0 and will be removed in 4.0.0.
A
RegionSplitRestriction implementation that groups rows by a prefix of the row-key with
a delimiter.See the instructions under hbase-examples/README.txt
A filter for adding inter-column timestamp matching Only cells with a correspondingly timestamped
entry in the target column will be retained Not compatible with Scan.setBatch as operations need
full rows for correct filtering
Failed deserialization.
Dictionary interface Dictionary indexes should be either bytes or shorts, only positive.
A utility class for managing compressor/decompressor dictionary loading and caching of load
results.
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 - ...
Base client for client/server implementations for the HBase delegation token auth'n method.
CallbackHandler for SASL DIGEST-MD5 mechanism
Utilities for interacting with and monitoring DirectByteBuffer allocations.
The thread pool used for scan directories
A
RegionSplitPolicy that disables region splits.A dummy RSGroupInfoManager which only contains a default rs group.
Take a snapshot of a disabled table.
No-op implementation of
WALProvider used when the WAL is disabled.The procedure for disabling a replication peer.
A
SpaceViolationPolicyEnforcement which disables the table.Exception Handler for Online Slow Log Ring Buffer
Wrapper around Hadoop's DNS class to hide reflection.
Subclass if exception is not meant to be retried: e.g.
Similar to RegionException, but disables retries.
A helper class to compute a scaled cost using
DescriptiveStatistics().a concrete column interpreter implementation.
Tracks the list of draining region servers via ZK.
Information about drilling down.
Driver for hbase mapreduce jobs.
Driver for hbase mapreduce jobs.
A query matcher for compaction which can drop delete markers.
Thrown during flush if the possibility snapshot content was not properly persisted into store
files.
Dropwizard metrics implementation of
Meter.Utility for doing JSON and MBeans.
Provides information about the existing states of replication, replication peers and queues.
Enum describing the durability guarantees for tables and
Mutations Note that the items
must be sorted in order of increasing durabilityThis is a class loader that can load classes dynamically from new jar files under a configured
folder.
An optional metrics registry class for creating and maintaining a collection of MetricsMutables,
making writing metrics source easier.
An empty ZooKeeper watcher
Handle the master side of taking a snapshot of an online table, regardless of snapshot type.
The procedure for enabling a replication peer.
Encapsulates a data block compressed using a particular encoding algorithm.
Internal error which indicates a bug in a data block encoding algorithm.
Keeps track of the encoding state.
A facade for encryption algorithms and related support.
Crypto context
Some static utility methods for encryption uses in hbase-client.
Encryptors apply a cipher to an OutputStream to produce ciphertext.
Coprocessors implement this interface to observe and mediate endpoint invocations on a region.
This ScanLabelGenerator enforces a set of predefined authorizations for a given user, the set
defined by the admin using the VisibilityClient admin interface or the set_auths shell command.
Lock for HBase Entity either a Table, a Namespace, or Regions.
Class which accumulates edits and separates them into a buffer per region while simultaneously
accounting RAM usage.
A buffer of some number of edits for a given region.
Has some basic interaction with the environment.
Manages a singleton instance of the environment edge.
Utility class for escape sequences.
Abstract base class for all HBase event handlers.
List of all HBase event handler types.
An example coprocessor that collects some metrics to demonstrate the usage of exporting custom
metrics from the coprocessor.
An example coprocessor that collects some metrics to demonstrate the usage of exporting custom
metrics from the coprocessor.
Common interface for metrics source implementations which need to track individual exception
types thrown or received.
Common base implementation for metrics sources which need to track exceptions thrown or received.
This class handles the different interruption classes.
The class to manage the excluded datanodes of the WALs on the regionserver.
The
ByteBuffAllocator won't allocate pooled heap ByteBuff now; at the same time,
if allocate an off-heap ByteBuff from allocator, then it must be a pooled one.IO engine that stores data to a file on the local block device using memory mapping mechanism
This is a generic executor service.
Executor instance.
A snapshot of the status of a particular executor.
The status of a particular event that is in the middle of being handled by an executor.
A subclass of ThreadPoolExecutor that keeps track of the Runnables that are executing at any
given point in time.
The Class ExecutorStatusChore for collect Executor status info periodically and report to metrics
system
The following is a list of all executor types, both those that run in the master and those that
run in the regionserver.
The cleaner to delete the expired MOB files.
This class is used for the tracking and enforcement of columns and numbers of versions during the
course of a Get or Scan operation, when explicit column qualifiers have been asked for in the
query.
Class to pick which files if any to compact together.
Simple exponential backoff policy on for the client that uses a percent^4 times the max backoff
to generate the backoff time.
Exponential compaction window implementation.
EMA is similar to
WeightedMovingAverage in weighted, but the weighting factor decrease
exponentially.Export an HBase table.
A simple example on how to use
Export.Export the specified snapshot to a given FileSystem.
Indicates the checksum comparison result.
Thrown when a snapshot could not be exported due to an error during the operation.
Some helper methods are used by
Export and
org.apache.hadoop.hbase.coprocessor.Export (in hbase-endpooint).Extension to
Cell with server side required functions.For internal purpose.
We use this class in HBase internally for getting
ExtendedCell directly without casting.We use this class in HBase internally for getting
ExtendedCell directly without casting.Similar to CellSerialization, but includes the sequenceId from an ExtendedCell.
Exception indicating that some files in the requested set could not be archived.
Thrown when we fail close of the write-ahead-log file.
Used internally signaling failed queue of a remote procedure operation.
Exception thrown if a mutation fails sanity checks.
Indicates that we're trying to connect to a already known as dead server.
A class to manage a list of servers that failed recently.
Thrown when we fail close of the write-ahead-log file.
Indicate that the rpc server tells client to fallback to simple auth but client is disabled to do
so.
This filter is used to filter based on the column family.
An asynchronous HDFS output stream implementation which fans out data to datanode and only
supports writing file with only one block.
Helper class for implementing
FanOutOneBlockAsyncDFSOutput.Exception other than RemoteException thrown when calling create on namenode
Helper class for adding sasl support for
FanOutOneBlockAsyncDFSOutput.Sets user name and password when asked by the client-side SASL object.
The asyncfs subsystem emulates a HDFS client by sending protobuf messages via netty.
Encoder similar to
DiffKeyDeltaEncoder but supposedly faster.FastLongHistogram is a thread-safe class that estimate distribution of data and computes the
quantiles.
Bins is a class containing a list of buckets(or bins) for estimation histogram of some data.
Balanced queue executor with a fastpath.
RPC Executor that extends
RWQueueRpcExecutor with fast-path feature, used in
FastPathBalancedQueueRpcExecutor.Thrown when server finds fatal issue w/ connection setup: e.g.
Helper class for FavoredNodeLoadBalancer that has all the intelligence for racks, meta scans,
etc.
An implementation of the
LoadBalancer that assigns favored
nodes for each region.Abstraction that allows different modules in RegionServer to update/get the favored nodes
information for regions.
FavoredNodesManager is responsible for maintaining favored nodes info in internal cache and META
table.
This class contains the mapping information between each region name and its favored region
server list.
An implementation of the
LoadBalancer that assigns favored
nodes for each region.If the passed in authorization is null, then this ScanLabelGenerator feeds the set of predefined
authorization labels for the given user.
Represents fields that are displayed in the top screen.
Information about a field.
The presentation logic for the field screen.
The screen where we can change the displayed fields, the sort key and the order of the fields.
Represents a value of a field.
Represents the type of a
FieldValue.FIFO compaction policy selects only files which have all cells expired.
A very simple RpcScheduler} that serves incoming requests in order.
Factory to use when you want to use the
FifoRpcSchedulerInterface allowing various implementations of tracking files that have recently been archived to
allow for the Master to notice changes to snapshot sizes for space quotas.
Factory class to create
FileArchiverNotifier instances.A factory for getting instances of
FileArchiverNotifier.Tracks file archiving and updates the hbase quota table.
An Exception thrown when SnapshotSize updates to hbase:quota fail to be written.
A struct encapsulating the name of a snapshot and its "size" on the filesystem.
A reference to a collection of files in the archive directory for a single region.
A file based store file tracker.
Instances of this class can be used to watch a directory for file changes.
General interface for cleaning files from a folder (generally an archive or backup folder).
IO engine that stores data to a file on the local file system.
Base class for instances of
KeyStoreLoader which load the key/trust stores from files on
a filesystem.Base class for builder pattern used by subclasses.
This file has been copied from the Apache ZooKeeper project.
The FileLink is a sort of hardlink, that allows access to a file given a set of locations.
FileLink InputStream that handles the switch between the original path and the alternative
locations, when the file is moved.
IO engine that stores data to a file on the specified file system using memory mapping mechanism
A chore which computes the size of each
HRegion on the FileSystem hosted by the given
HRegionServer.Thrown when the file system needs to be upgraded
Interface for row and column filters directly applied within the regionserver.
Return codes for filterValue().
Abstract base class to help you implement new Filters.
A container interface to add javax.servlet.Filter.
The presentation logic for the filter display mode.
The filter display mode in the top screen.
Initialize a javax.servlet.Filter.
Implementation of
Filter that represents an ordered List of Filters which will be
evaluated with a specified boolean operator FilterList.Operator.MUST_PASS_ALL (AND) or
FilterList.Operator.MUST_PASS_ONE (OR).set operator
Base class for FilterList.
FilterListWithAND represents an ordered list of filters which will be evaluated with an AND
operator.
FilterListWithOR represents an ordered list of filters which will be evaluated with an OR
operator.
This is a Filter wrapper class which is used in the server side.
A filter that will only return the first KV from each row.
In-memory BlockCache that may be backed by secondary layer(s).
The
HFile has a fixed trailer which contains offsets to other variable parts of the file.With this limiter resources will be refilled only after a fixed interval of time.
Wraps an existing
DataType implementation as a fixed-length version of itself.A
FlushPolicy that only flushes store larger a given threshold.A
FlushPolicy that always flushes all stores for a given region.A
FlushPolicy that only flushes store larger a given threshold.Used to track flush execution.
A
FlushPolicy that only flushes store larger than a given threshold.A flush policy determines the stores that need to be flushed when flushing a region.
The class that creates a flush policy from a conf and HTableDescriptor.
Request a flush.
Listener which will get notified regarding flush requests of regions.
This online snapshot implementation uses the distributed procedure framework to force a store
flush and then records the hfiles.
Callable for adding files to snapshot manifest working dir.
This flush region implementation uses the distributed procedure framework to flush table regions.
Reasons we flush.
Check whether forbid major compaction for region.
A ForeignException is an exception from another thread or process.
This is a Proxy Throwable that contains the information of the original remote exception
The dispatcher acts as the state holding entity for foreign error handling.
The ForeignExceptionListener is an interface for objects that can receive a ForeignException.
This is an interface for a cooperative exception throwing mechanism.
Wrapper for input stream(s) that takes care of the interaction of FS and HBase checksums, as well
as closing streams.
Helper class to obtain a filesystem delegation token.
The original implementation of FSWAL.
A WAL provider that use
FSHLog.Thread that walks over the filesystem, and computes the mappings Region -> BestHost and Region ->
Map<HostName, fractional-locality-of-region>A filesystem based replication peer storage.
Implementation of
TableDescriptors that reads descriptors from the passed filesystem.Utility methods for interacting with the underlying file system.
Directory filter that doesn't include any of the directories in the specified blacklist
A
PathFilter that only allows directories.Filter for all dirs that are legal column family names.
A
PathFilter that returns only regular files.Filter for HFiles that excludes reference files.
Filter for HFileLinks (StoreFiles and HFiles not included).
Called every so-often by storefile map builder getTableStoreFilePathMap to report progress.
Filter for all dirs that don't start with '.'
A
PathFilter that returns usertable directories.Utility methods for interacting with the hbase.root file system.
A WAL Entry for
AbstractFSWAL implementation.Full table backup implementation
Helper class for processing futures.
This is optimized version of a standard FuzzyRowFilter Filters data based on fuzzy row key.
Abstracts directional comparisons based on scan direction.
A metrics which measures a discrete value.
Deprecated.
2.3.0 Use
GCMultipleMergedRegionsProcedure.GC regions that have been Merged.
GC a Region that is no longer in use.
Used to perform Get operations on a single row.
A generic way for querying Java properties.
This class acts as an adapter to export the MetricRegistry's in the global registry.
Represents an authorization for access whole cluster.
Procedure interface for global operations, such as migration.
An object which captures all quotas types (throttle or space) for a subject (user, table, or
namespace).
Implementation of
GlobalQuotaSettings to hide the Protobuf messages we use internally.Extract grouping columns from input record
Extract grouping columns from input record.
Provides a singleton
Gson instance configured just the way we like it.Implements JSON serialization via
Gson for JAX-RS.Used to register with (shaded) Jersey the presence of Entity serialization using (shaded) Gson.
Register this feature's provided functionality and defines their lifetime scopes.
Helper class for gson.
Base client for client/server implementations for the "KERBEROS" HBase auth'n method.
CallbackHandler for SASL GSSAPI Kerberos mechanism
HadoopCompressor<T extends io.airlift.compress.Compressor>
Hadoop compressor glue for aircompressor compressors.
HadoopDecompressor<T extends io.airlift.compress.Decompressor>
Hadoop decompressor glue for aircompressor decompressors.
A facade for a
HFile.Reader that serves up either the
top or bottom half of a HFile where 'bottom' is the first half of the file containing the keys
that sort lowest and 'top' is the second half of the file with keys that sort greater than those
of the bottom half.This class represents a common API for hashing functions.
This class encapsulates a byte array and overrides hashCode and equals so that it's identity is
based on the data rather than the array instance.
Used to calculate the hash
Hash algorithms for Bloomfilters.Deprecated.
Since 2.0.0 to be removed in 4.0.0.
Deprecated.
Since 2.0.0 to be removed in 4.0.0.
View to an on-disk Backup Image FileSytem Provides the set of methods necessary to interact with
the on-disk Backup Image data.
Deprecated.
since 3.0.0, will be removed in 4.0.0.
Deprecated.
since 3.0.0, will be removed in 4.0.0.
Adds HBase configuration files to a Configuration
Tool that prints out a configuration.
Base checked exception in HBase.
Deprecated.
For removal in hbase-4.0.0.
This is a Tool wrapper that gathers -Dxxx=yyy configuration settings from the command line.
Contact hdfs and get all information about specified table directory into regioninfo list.
Contact a region server and get all information from it
This class contains helper methods that repair parts of hbase's filesystem contents.
Converts a Hbase.Iface using InvocationHandler so that it reports process time of each call to
ThriftMetrics.
Use
Connection.getHbck() to obtain an instance of Hbck instead of constructing an
HBaseHbck directly.When enabled in
X509Util, handles verifying that the hostname of a peer matches the
certificate it presents.Note: copied from Apache httpclient with some minor modifications.
A
ReplicationEndpoint implementation for replicating
to another HBase cluster.This class defines constants for different classes of hbase limited private apis
All hbase specific IOExceptions should be subclasses of HBaseIOException
This is the adapter from "HBase Metrics Framework", implemented in hbase-metrics-api and
hbase-metrics modules to the Hadoop Metrics2 framework.
Implementation of secure Hadoop policy provider for mapping protocol interfaces to
hbase-policy.xml entries.
The HBaseReferenceCounted disabled several methods in Netty's
ReferenceCounted, because
those methods are unlikely to be used.A
BaseReplicationEndpoint for replication endpoints whose target cluster is an HBase
cluster.Wraps a replication region server sink to provide the ability to identify it.
Optionally carries Cells across the proxy/service interface down into ipc.
Get instances via
RpcControllerFactory on client-side.An interface for calling out of RPC for error conditions.
Base class for Master and RegionServer RpcServices.
A utility class that encapsulates SASL logic for RPC client.
A utility class that encapsulates SASL logic for RPC server.
The constants in this class correspond with the guidance outlined by the OpenTelemetry Semantic
Conventions.
These are values used with
HBaseSemanticAttributes.DB_OPERATION.These values represent the different IO read strategies HBase may employ for accessing
filesystem data.
These are values used with
HBaseSemanticAttributes.RPC_SYSTEM.Base class for hbase services, such as master or region server.
Base class for exceptions thrown by an HBase server.
abstract class for HBase handler providing a Connection cache and get table/admin method
General exception base class for when a snapshot fails.
Deprecated.
since 3.0.0, will be removed in 4.0.0.
A tracker for tracking and validating table rows generated with
HBaseTestingUtility.loadTable(Table, byte[])A custom TrustManager that supports hostname verification We attempt to perform verification
using just the IP address first and if that fails will attempt to perform a reverse DNS lookup
and verify using the hostname.
Deprecated.
since 3.0.0, will be removed in 4.0.0.
Hbck fixup tool APIs.
Used to do the hbck checking job at master side.
POJO to present Empty Region Info from Catalog Janitor Inconsistencies Report via REST API.
Deprecated.
Since 2.3.0.
POJO to present HBCK Inconsistent Regions from HBCK Inconsistencies Report via REST API.
This class exposes hbck.jsp report as JSON Output via /hbck/hbck-metrics API.
The root object exposing hbck.jsp page as JSON Output.
POJO to present Orphan Region on FS from HBCK Inconsistencies Report via REST API.
POJO to present Orphan Region on RS from HBCK Inconsistencies Report via REST API.
POJO to present Region Overlap from Catalog Janitor Inconsistencies Report via REST API.
POJO class for HBCK RegionInfo in HBCK Inconsistencies report.
POJO to present Region Holes from Catalog Janitor Inconsistencies Report via REST API.
Maintain information about a particular region.
Stores the regioninfo entries from HDFS
Stores the regioninfo entries scanned from META
Stores the regioninfo retrieved from Online region servers.
The result of an
HbckChore execution.Acts like the super class in all cases except when no Regions found in the current Master
in-memory context.
Visitor for hbase:meta that 'fixes' Unknown Server issues.
POJO class for ServerName in HBCK Inconsistencies report.
Maintain information about a particular table.
POJO to present Unknown Regions from Catalog Janitor Inconsistencies Report via REST API.
A real-time monitoring tool for HBase like Unix top command.
HConstants holds a bunch of HBase-related constants
Status codes used for return values of bulk operations.
Data structure to describe the distribution of HDFS blocks among hosts.
Stores the hostname and weight for that hostname.
Comparator used to sort hosts based on weight
Implementations 'visit' hostAndWeight.
Represents headers for the metrics in the top screen.
The Class HealthCheckChore for running health checker regularly.
A utility for executing an external script that checks the health of the node.
The Class HealthReport containing information about health of the node.
A pooled ByteBufAllocator that does not prefer direct buffers regardless of platform settings.
Manages tuning of Heap memory using
HeapMemoryTuner.Every class that wants to observe heap memory tune actions must implement this interface.
POJO to pass all the relevant information required to do the heap memory tuning.
POJO which holds the result of memory tuning done by HeapMemoryTuner implementation.
Makes the decision regarding proper sizing of the heap memory.
Implementations can be asked for an estimate of their size in bytes.
Successful running of this application requires access to an active instance of HBase.
Successful running of this application requires access to an active instance of HBase.
The presentation logic for the help screen.
The help screen.
This is an optional Cost function designed to allow region count skew across RegionServers.
File format for hbase.
An abstraction used by the block index.
An interface used by clients to open and iterate an
HFile.API required to write an
HFileThis variety of ways to construct writers is used throughout the code, and we want to be able
to swap writer implementations.
Client-side manager for which table's hfiles should be preserved for long-term archive.
Utility class to handle the removal of HFiles (or the respective
StoreFiles)
for a HRegion from the FileSystem.Wrapper to handle file operations uniformly
Adapt a type to match the
HFileArchiver.File interface, which is used internally for handling
archival/removal of filesConvert a FileStatus to something we can manage in the archiving
Convert the
HStoreFile into something we can manage in the archive methodsMonitor the actual tables for which HFiles are archived for long-term retention (always kept
unless ZK state changes).
Helper class for all utilities related to archival/retrieval of HFiles
Cacheable Blocks of an
HFile version 2 file.Iterator for reading
HFileBlocks in load-on-open-section, such as root data index
block, meta index block, file info block etc.Something that can be written into a block.
An HFile block reader with iteration ability.
Reads version 2 HFile blocks from the filesystem.
Data-structure to use caching the header of the NEXT block.
Unified version 2
HFile block writer.A decoding context that is created by a reader's encoder, and is shared across all of the
reader's read operations.
A default implementation of
HFileBlockDecodingContext.A default implementation of
HFileBlockEncodingContext.An encoding context that is created by a writer's encoder, and is shared across the writer's
whole lifetime.
Provides functionality to write (
HFileBlockIndex.BlockIndexWriter) and read BlockIndexReader single-level
and multi-level block indexes.A single chunk of the block index in the process of writing.
The reader will always hold the root level index in the memory.
Writes the block index into the output stream.
An implementation of the BlockIndexReader that deals with block keys which are plain byte[]
like MetaBlock or the Bloom Block for ROW bloom.
An implementation of the BlockIndexReader that deals with block keys which are the key part of
a cell like the Data block index or the ROW_COL bloom blocks This needs a comparator to work
with the Cells
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.
Read-only HFile Context Information.
Populate fields on an
AttributesBuilder based on an HFileContext.A builder that helps in building up the HFileContext
This class marches through all of the region's hfiles and verifies that they are all valid files.
Controls what kind of data block encoding is used.
Do different kinds of data block encoding according to column family options.
Controls what kind of index block encoding is used.
Do different kinds of index block encoding according to column family options.
Metadata Map of attributes for HFile written out as HFile Trailer.
Simple MR input format for HFiles.
Record reader for HFiles.
HFileLink describes a link to an hfile.
HFileLink cleaner that determines if a hfile should be deleted.
Writes HFiles.
Implementation of
HFile.Reader to deal with pread.Implements pretty-printing functionality for
HFiles.Holds a Histogram and supporting min/max and range buckets for analyzing distribution of key
bytes, value bytes, row bytes, and row columns.
Simple reporter which collects registered histograms for printing to an output stream in
HFilePrettyPrinter.SimpleReporter.report().A builder for
HFilePrettyPrinter.SimpleReporter instances.A tool to dump the procedures in the HFiles.
Implementation that can handle all hfile versions of
HFile.Reader.Scanner that operates on encoded data blocks.
An exception thrown when an operation requiring a scanner to be seeked is invoked on a scanner
that is not seeked.
It is used for replicating HFile entries.
A scanner allows you to position yourself within a HFile and scan through it.
Implementation of
HFile.Reader to deal with stream read do not perform any prefetch
operations (HFilePreadReader will do this).An encapsulation for the FileSystem object that hbase uses to access data.
Interface to implement to add a specific reordering logic in hdfs.
We're putting at lowest priority the wal files blocks that are on the same datanode as the
original regionserver which created these files.
Common functionality needed by all versions of
HFile writers.Marker interface for filters that may return SEEK_NEXT_USING_HINT.
A metric which measures the distribution of values.
Custom histogram implementation based on FastLongHistogram.
HMaster is the "master server" for HBase.
Implement to return TableDescriptor after pre-checks
The store implementation to save MOBs (medium objects), it extends the HStore.
HBase's version of ZooKeeper's QuorumPeer.
Regions store data for a certain region of a table.
Class that tracks the progress of a batch operations, accumulating status codes and tracking
the index at which processing is proceeding.
Visitor interface for batch operations
Listener class to enable callers of bulkLoadHFile() to perform any necessary pre/post
processing of a given bulkload call
Objects from this class are created when flushing to describe all the different states that
that method ends up in.
Batch of mutation operations.
A class that tracks exceptions that have been observed in one batch.
A result object from prepare flush cache stage
Deprecated.
Since 3.0.0, will be removed in 4.0.0.
Class used to represent a lock on a row.
View to an on-disk Region.
Data structure to hold RegionInfo and the address for the hosting HRegionServer.
This is used to partition the output keys into groups of keys.
This is used to partition the output keys into groups of keys.
HRegionServer makes a set of HRegions available to clients.
Inner class that runs on a long period checking if regions need compaction.
Force to terminate region server when abort timeout.
Class responsible for parsing the command line and starting the RegionServer.
A Wrapper for the region FileSystem operations adding WAL specific operations
A Store holds a column family in a Region.
A Store data file.
A TThreadedSelectorServer.Args that reads hadoop configuration
This class is responsible for quoting HTML characters.
Statics to get access to Http related configuration.
See the instructions under hbase-examples/README.txt
A simple example on how to use
AsyncTable to write a fully
asynchronous HTTP proxy server.RequestLog object for use with Http
Create a Jetty embedded server to answer http requests.
Class to construct instances of HTTP server with specific options.
A Servlet input filter that quotes all HTML active characters in the parameter names and
values.
A very simple servlet to serve up a text representation of the current stack traces.
HttpServer utility.
Pass the given key and record as-is to reduce
Pass the given key and record as-is to the reduce phase.
Write to table each key, record pair
Allows multiple concurrent clients to lock on a numeric id with a minimal memory overhead.
An entry returned to the client as a lock object
Allows multiple concurrent clients to lock on a numeric id with ReentrantReadWriteLock.
Exception thrown when an illegal argument is passed to a function/procedure.
Mainly used as keys for HashMap.
A byte sequence that is usable as a key or value.
A Comparator optimized for ImmutableBytesWritable.
A MemStoreLAB implementation which wraps N MemStoreLABs.
Immutable version of Scan
ImmutableSegment is an abstract class that extends the API supported by a
Segment, and is
not needed for a MutableSegment.An enum of server implementation selections
Import data written by
Export.A mapper that just writes out KeyValues.
Write table content out to files in hdfs.
Tool to import data from a TSV file.
A compaction query matcher that always return INCLUDE and drops nothing.
A Filter that stops after the given row.
Used to indicate a filter incompatibility
Split size is the number of regions that are on this server that all are of the same table,
cubed, times 2x the region flush size OR the maximum region split size, whichever is smaller.
Used to perform Increment operations on a single row.
After a full backup was created, the incremental backup will only store the changes made after
the last full or incremental backup.
Incremental backup implementation.
This class will coalesce increments from a thift server if
hbase.regionserver.thrift.coalesceIncrement is set to true.
Used to identify a cell that will be incremented.
Uses an incrementing algorithm instead of the default.
Provide access to all index block encoding algorithms.
Example map/reduce job to construct index tables that can be used to quickly find a row based on
the value of a column.
Internal Mapper to be run by Hadoop.
An on heap block cache implementation extended LruBlockCache and only cache index block.
Create a Jetty embedded server to answer http requests.
Procedure for setting StoreFileTracker information to table descriptor.
This procedure is used to initialize meta table for a new hbase deploy.
A way to write "inline" blocks into an
HFile.Inline Chores (executors internal chores).
A procedure iterator which holds all the procedure protos in memory.
Compare two HBase cells inner store, skip compare family for better performance.
The presentation logic for the input mode.
The input mode in the top screen.
Computes the HDFSBlockDistribution for a file based on the underlying located blocks for an
HdfsDataInputStream reading that file.
Placeholder of an instance which will be accessed by other threads but is not yet created.
The actual class for operating on log4j2.
Special scanner, currently used for increment operations to allow additional server-side
arguments for Scan operations.
Internal scanners differ from client-side scanners in that they operate on HStoreKeys and byte[]
instead of RowResults.
Helpers to create interned metrics info
Thrown if a request is table schema modification is requested but made for an invalid family
name.
Thrown when an invalid HFile format is detected
Thrown if Mutation's
Durability is skip wal but table need replication.Used to indicate an invalid RowFilter.
A class implementing IOEngine interface supports data services for
BucketCache.A supplier that throws IOException when get.
Construct
Span instances originating from the client side of an IPC.Construct
Span instances originating from the server side of an IPC.Utility to help ipc'ing.
Specify Isolation levels in Scan operations.
Finds the Jar for a class.
Plumbing for hooking up Jersey's JSON entity body encoding and decoding support to JAXB.
Produces 32-bit hash for hash table lookup.
ScheduledThreadPoolExecutor that will add some jitter to the RunnableScheduledFuture.getDelay.
Implementation of
FileKeyStoreLoader that loads from JKS files.JMX caches the beans that have been exported; even after the values are removed from hadoop's
metrics system the keys and old values will still remain.
Provides Read only web access to JMX.
Pluggable JMX Agent for HBase(to fix the 2 random TCP ports issue of the out-of-the-box JMX
Agent): 1)connector port can share with the registry port if SSL is OFF 2)support password
authentication 3)support subset of SSL (with default configuration)
Utility methods to interact with a job.
Utility class for converting objects to JRuby.
Utility for doing JSON and MBeans.
Use dumping out mbeans as JSON.
Utility class for converting objects to JSON
Setup
SLF4JBridgeHandler.This class is a wrapper for the implementation of com.sun.management.UnixOperatingSystemMXBean It
will decide to use the sun api or its own implementation depending on the runtime (vendor) used.
Utility used running a cluster all in the one JVM.
Datastructure to hold Master Thread and Master instance
Datastructure to hold RegionServer Thread and RegionServer instance
Class which sets up a simple thread which runs in a loop sleeping for a short interval of time.
Interface for sources that will export JvmPauseMonitor metrics
Utility class to get and check the current JVM version.
Ways to keep cells marked for delete around.
A utility class to manage a set of locks.
A filter that will only return the key component of each KV (the value will be rewritten as
empty).
Deprecated.
since 3.0.0 and will be removed in 4.0.0.
A
RegionSplitRestriction implementation that groups rows by a prefix of the row-key.Represents the user pressing a key on the keyboard.
This generates
KeyPress objects from the given input stream and offers them to the given
queue.KeyProvider is a interface to abstract the different methods of retrieving key material from key
storage such as Java key store.
A key range use in split coverage.
This enum represents the file type of a KeyStore or TrustStore.
A basic KeyProvider that can resolve keys from a protected KeyStore file on the local filesystem.
An interface for an object that can load key stores or trust stores.
An HBase Key/Value.
A simple form of KeyValue that creates a keyvalue with only the key part of the byte[] Mainly
used in places where we need to compare two cells.
Avoids redundant comparisons for better performance.
Key type.
Codec that does KeyValue version 1 serialization.
Codec that does KeyValue version 1 serialization with serializing tags also.
Implements a heap merge across any number of KeyValueScanners.
Scanner that returns the next KeyValue.
static convenience methods for dealing with KeyValues and collections of KeyValues
Last flushed sequence Ids for the regions and their stores on region server
A lazy initialized WAL provider for holding the WALProvider for some special tables, such as
hbase:meta, hbase:replication, etc.
Reports a problem with a lease
LeaseListener is an interface meant to be implemented by users of the Leases class.
Leases There are several server classes in HBase that need to track external clients that
occasionally send heartbeats.
This class tracks a single Lease.
Thrown if we are asked to create a lease but lease on passed name already exists.
Thrown when the lease was expected to be recovered, but the file can't be opened.
Makes decisions about the placement and movement of Regions across RegionServers.
The class that creates a load balancer from a conf.
Store the balancer state.
This class creates a single process HBase cluster.
Compute a cost of a potential cluster configuration based upon where
HStoreFiles are located.hadoop 3.3.1 changed the return value of this method from
DatanodeInfo[] to
DatanodeInfoWithStorage[], which causes the JVM can not locate the method if we are
compiled with hadoop 3.2 and then link with hadoop 3.3+, so here we need to use reflection to
make it work for both hadoop versions, otherwise we need to publish more artifacts for different
hadoop versions...Locking for mutual exclusion between procedures.
Functions to acquire lock on table/namespace/regions.
Procedure to allow blessed clients and external admin tools to take our internal Schema locks
used by the procedure framework isolating procedures doing creates/deletes etc.
Helper class to create "master locks" for namespaces, tables and regions.
Interface to get status of a Lock without getting access to acquire/release lock.
A bridge class for operating on log4j, such as changing log level, etc.
This Chore, every time it runs, will attempt to delete the WALs and Procedure WALs in the old
logs folder.
Abstract response class representing online logs response from ring-buffer use-cases e.g
slow/large RPC logs, balancer decision logs
Event Handler run by disruptor ringbuffer consumer.
Event Handler utility class
Change log level in runtime.
Valid command line options.
A servlet implementation
Utility functions for reading the log4j logs that are being written by HBase.
Deprecated.
as of 2.4.0.
This backup sub-procedure implementation forces a WAL rolling on a RS.
Handle running each of the individual tasks for completing a backup procedure on a region server.
Runs periodically to determine if the WAL should be rolled.
Master procedure manager for coordinated cluster-wide WAL roll operation, which is run during
backup operation, see
MasterProcedureManager and RegionServerProcedureManagerThis manager class handles the work dealing with distributed WAL roll request.
a concrete column interpreter implementation.
A long comparator which numerical compares against the specified byte array
BaseHFileCleanerDelegate that only cleans HFiles that don't belong to a table that is
currently being archived.LossyCounting utility, bounded data structure that maintains approximate high frequency elements
in data stream.
This realisation improve performance of classical LRU cache up to 3 times via reduce GC
job.
A block cache implementation that is memory-aware using
HeapSize, memory-bound using an
LRU eviction algorithm, and concurrent: backed by a ConcurrentHashMap and with a
non-blocking eviction thread giving constant-time LruBlockCache.cacheBlock(org.apache.hadoop.hbase.io.hfile.BlockCacheKey, org.apache.hadoop.hbase.io.hfile.Cacheable, boolean) and LruBlockCache.getBlock(org.apache.hadoop.hbase.io.hfile.BlockCacheKey, boolean, boolean, boolean)
operations.Represents an entry in the
LruBlockCache.A memory-bound queue that will grow until an element brings total size >= maxSize.
WALDictionary using an LRU eviction algorithm.
Hadoop Lz4 codec implemented with aircompressor.
Hadoop Lz4 codec implemented with lz4-java.
Hadoop compressor glue for lz4-java.
Hadoop decompressor glue for lz4-java.
Hadoop Lzo codec implemented with aircompressor.
a balancer which is only used in maintenance mode.
Query matcher for major compaction.
This request helps determine if a region has to be compacted based on table's TTL.
This tool compacts a table's regions that are beyond it's TTL.
An environment edge that uses a manually set value.
BaseHFileCleanerDelegate that prevents cleaning HFiles from a mob region keeps a map of
table name strings to mob region name strings over the life of a JVM instance.Map-Reduce implementation of
BackupCopyJob.MapReduce implementation of
BackupMergeJob Must be initialized with configuration of a
backup destination clusterGenerate a classpath string containing any jars required by mapreduce jobs.
A wrapper for a cell to be used with mapreduce, as the output value class for mappers/reducers.
A tool to split HFiles into new region boundaries as a MapReduce job.
A mapper that just writes out cells.
MapReduce implementation of
RestoreJob For backup restore, it runs
MapReduceHFileSplitterJob job and creates HFiles which are aligned with a region
boundaries of a table being restored.Tracks the active master address on server ZK cluster and synchronize them to client ZK cluster
if changed
Manages the location of the current active Master for the RegionServer.
Priority function specifically for the master.
Master based cluster info provider.
Provides the coprocessor framework and environment for master oriented operations.
Coprocessor environment extension providing access to master related services.
Special version of MasterEnvironment that exposes MasterServices for Core Coprocessors only.
The implementation of a master based coprocessor rpc channel.
Helper class for schema change procedures
Implements a Singleton binding to the provided instance of
HMaster for both
HMaster and MasterServices injections.A special RpcScheduler} only used for master.
Factory to use when you want to use the
MasterFifoRpcSchedulerThis class abstracts a bunch of operations the HMaster needs to interact with the underlying file
system like creating the initial layout, checking file system status, etc.
Protection against zombie master.
Tracks the master Maintenance Mode via ZK.
Thrown if the master is not running
Defines coprocessor hooks for interacting with operations on the
HMaster process.A life-cycle management interface for globally barriered procedures on master.
Provides the globally barriered procedure framework and environment for master oriented
operations.
ProcedureScheduler for the Master Procedures.
Helper Runnable used in conjunction with submitProcedure() to deal with submitting procs with
nonce.
Master Quota Manager.
Encapsulates CRUD quota operations for some subject.
Holds the size of a region at the given time, millis since the epoch.
An observer to automatically delete quotas when a table/namespace is deleted.
A region that stores data in a separated directory, which can be used to store master local data.
The factory class for creating a
MasterRegion.As long as there is no RegionServerServices for a master local region, we need implement the
flush and compaction logic by our own.
The parameters for constructing
MasterRegion.MasterRegion based RegionServerList.As long as there is no RegionServerServices for a master local region, we need implement log
roller logic by our own.
Deprecated.
Since 2.5.0, will be removed in 4.0.0.
Exception thrown when an master registry RPC fails in client.
Implements the master RPC services.
A wrapper class for MasterRpcServices shortcut that ensures a client version is available to the
callee without a current RPC call.
A curated subset of services provided by
HMaster.General snapshot verification on the master.
A state storage which stores the state in master local region.
The servlet responsible for rendering the index page of the master.
Thrown when the master is stopped
Represents the master switch type
This class abstracts a bunch of operations the HMaster needs when splitting log files e.g.
Object that will register an mbean with the underlying metrics implementation.
Hadoop2 metrics2 implementation of an object that registers MBeans.
Utility class for MD5 MD5 hash produces a 128-bit digest.
Class to store blocks into memcached.
Class to encode and decode an HFileBlock to and from memecached's resulting byte arrays.
A size-bounded repository of alerts, which are kept in a linked list.
Enum describing all possible memory compaction policies
Util class to calculate memory size for memstore(on heap, off heap), block cache(L1, L2) of RS.
The MemStore holds in-memory modifications to the Store.
MemStoreCompactionStrategy is the root of a class hierarchy which defines the strategy for
choosing the next action to apply in an (in-memory) memstore compaction.
Types of actions to be done on the pipeline upon MemStoreCompaction invocation.
The ongoing MemStore Compaction manager, dispatches a solo running compaction and interrupts the
compaction if requested.
The MemStoreCompactorSegmentsIterator extends MemStoreSegmentsIterator and performs the scan for
compaction operation meaning it is based on SQM
Thread that flushes cache on request NOTE: This class extends Thread rather than Chore because
the sleep time can be interrupted when there is something to do, rather than the Chore sleep time
which is invariant.
Datastructure used in the flush queue.
A memstore-local allocation buffer.
A memstore-local allocation buffer.
The MemStoreMergerSegmentsIterator extends MemStoreSegmentsIterator and performs the scan for
simple merge operation meaning it is NOT based on SQM
The MemStoreSegmentsIterator is designed to perform one iteration over given list of segments For
another iteration new instance of MemStoreSegmentsIterator needs to be created The iterator is
not thread-safe and must have only one instance per MemStore in each period of time
Data structure of three longs.
Compute the cost of total memstore size.
Accounting of current heap and data sizes.
MemStoreSnapshot is a Context Object to hold details of the snapshot taken on a MemStore.Normalization plan to merge adjacent regions.
A helper for constructing instances of
MergeNormalizationPlan.Thrown when something is wrong in trying to merge two regions.
The procedure to Merge regions in a table.
Codec that just writes out Cell as a protobuf Cell Message.
The presentation logic for the message mode.
The message mode in the top screen.
Support class for the "Meta Entries" section in
resources/hbase-webapps/master/table.jsp.Server-side fixing of bad or inconsistent state in hbase:meta.
A union over
MetaFixer.Either and MetaFixer.Either.Tracks the meta region locations on server ZK cluster and synchronize them to client ZK cluster
if changed
The field or the parameter to which this annotation can be applied only when it holds mutations
for hbase:meta table.
Deprecated.
only used for
RecoverMetaProcedure.Deprecated.
only used for
RecoverMetaProcedure.A cache of meta region location metadata.
RPC Executor that uses different queues for reads and writes for meta.
Read/write operations on
hbase:meta region as well as assignment information stored
to hbase:meta.Utility class to perform operation (get/wait for/verify/set/delete) on znode in ZooKeeper which
keeps hbase:meta region server location.
A coprocessor that collects metrics from meta table.
A metric which measure the rate at which some operation is invoked.
Parent interface for all metrics.
Metrics Histogram interface.
Specifies a quantile (with error bounds) to be watched by a
MetricSampleQuantiles object.MetricRegistries is collection of MetricRegistry's.
Implementation of MetricRegistries that does ref-counting.
General purpose factory for creating various metrics.
A Factory for creating MetricRegistries.
Custom implementation of
MetricRegistry.HBase Metrics are grouped in different MetricRegistry'ies.
Implementation of the Cormode, Korn, Muthukrishnan, and Srivastava algorithm for streaming
calculation of targeted high-percentile epsilon-approximate quantiles.
Describes a measured value passed to the estimator, tracking additional metadata required by
the CKMS algorithm.
Faced for exposing metrics about the balancer.
This class is for maintaining the various connection statistics and publishing them through the
metrics interfaces.
A container class for collecting details about the RPC call as it percolates.
A lambda for dispatching to the appropriate metric factory method
Utility class for tracking metrics for various types of coprocessors.
A set of named metrics.
ScheduledExecutorService for metrics.
Class to handle the ScheduledExecutorService
ScheduledExecutorService used by
MetricsRegionAggregateSourceImpl, and JmxCacheBusterThis class is for maintaining the various regionserver's heap memory manager statistics and
publishing them through the metrics interfaces.
This interface will be implemented by a MetricsSource that will export metrics from
HeapMemoryManager in RegionServer into the hadoop metrics system.
Hadoop2 implementation of MetricsHeapMemoryManagerSource.
Making implementing metric info a little easier
This class is for maintaining the various master statistics and publishing them through the
metrics interfaces.
Interface that classes that expose metrics about the master will implement.
Interface of a factory to create MetricsMasterSource when given a MetricsMasterWrapper
Factory to create MetricsMasterProcSource when given a MetricsMasterWrapper
Hadoop2 implementation of MetricsMasterSource.
A collection of exposed metrics for space quotas from the HBase Master.
Interface of a factory to create MetricsMasterQuotaSource when given a MetricsMasterWrapper.
Factory to create MetricsMasterQuotaSource instances when given a MetricsMasterWrapper.
Implementation of
MetricsMasterQuotaSource which writes the values passed in via the
interface to the metrics backend.Interface that classes that expose metrics about the master will implement.
Interface of a factory to create MetricsMasterSource when given a MetricsMasterWrapper
Factory to create MetricsMasterSource when given a MetricsMasterWrapper
Hadoop2 implementation of MetricsMasterSource.
This is the interface that will expose information to hadoop1/hadoop2 implementations of the
MetricsMasterSource.
Impl for exposing HMaster Information through JMX
This is the glue between the HRegion and whatever hadoop shim layer is loaded
(hbase-hadoop1-compat or hbase-hadoop2-compat).
This interface will be implemented by a MetricsSource that will export metrics from multiple
regions into the hadoop metrics system.
Maintains regionserver statistics and publishes them through the metrics interfaces.
A collection of exposed metrics for space quotas from an HBase RegionServer.
Implementation of
MetricsRegionServerQuotaSource.Interface for classes that expose metrics about the regionserver.
Interface of a factory to create Metrics Sources used inside of regionservers.
Factory to create MetricsRegionServerSource when given a MetricsRegionServerWrapper
Hadoop2 implementation of MetricsRegionServerSource.
This is the interface that will expose RegionServer information to hadoop1/hadoop2
implementations of the MetricsRegionServerSource.
Impl for exposing HRegionServer Information through Hadoop's metrics 2 system.
This interface will be implemented to allow single regions to push metrics into
MetricsRegionAggregateSource that will in turn push data to the Hadoop metrics system.
Interface of class that will wrap an HRegion and export numbers so they can be used in
MetricsRegionSource
Provides access to gauges and counters.
Hadoop2 implementation of MetricsReplicationSource.
This is the metric source for table level replication metrics.
Interface of the Metrics Source that will export data to Hadoop's Metrics2 system.
Hadoop Two implementation of a metrics2 source that will export metrics from the Rest server to
the hadoop metrics2 subsystem.
This class is for maintaining the various replication statistics for a sink and publishing them
through the metrics interfaces.
This class is for maintaining the various replication statistics for a source and publishing them
through the metrics interfaces.
This metrics balancer uses extended source for stochastic load balancer to report its related
metrics to JMX.
This interface extends the basic metrics balancer source to add a function to report metrics that
related to stochastic load balancer.
This interface will be implemented by a MetricsSource that will export metrics from multiple
regions of a table into the hadoop metrics system.
This interface will be implemented to allow region server to push table metrics into
MetricsRegionAggregateSource that will in turn push data to the Hadoop metrics system.
Interface of class that will wrap a MetricsTableSource and export numbers so they can be used in
MetricsTableSource
Interface of a class that will export metrics about Thrift to hadoop's metrics2.
Factory that will be used to create metrics sources for the two diffent types of thrift servers.
Class used to create metrics sources for Thrift and Thrift2 servers.
A singleton used to make sure that only one thrift metrics source per server type is ever
created.
Hadoop 2 version of
MetricsThriftServerSource Implements
BaseSource through BaseSourceImpl, following the patternThis interface will be implemented by a MetricsSource that will export metrics from multiple
users into the hadoop metrics system.
Class used to push numbers about the WAL into the metrics subsystem.
Interface of the source that will export metrics about the region server's WAL.
Class that transitions metrics from MetricsWAL into the metrics subsystem.
Interface of the source that will export metrics about the ZooKeeper.
Class that transitions metrics from MetricsZooKeeper into the metrics subsystem.
Migrate the namespace data to meta table's namespace family while upgrading
A procedure for migrating replication queue data from zookeeper to hbase:replication table.
Procedure for migrating rs group information to table descriptor.
A store file tracker used for migrating between store file tracker implementations.
Wraps together the mutations which are applied as a batch to the region and their operation
status and WALEdits.
Deprecated.
since 3.0.0, will be removed in 4.0.0.
Subclass so can get at protected methods (none at moment).
Alternate shutdown hook.
TODO: Most of the code in this class is ripped from ZooKeeper tests.
Query matcher for minor compaction.
A
SpaceViolationPolicyEnforcement which can be treated as a singleton.The MobCell will maintain a
Cell and a StoreFileScanner inside.Enum describing the mob compact partition policy types.
The constants used in mob.
The mob file.
The cache for mob files.
The class MobFileCleanerChore for running cleaner regularly to remove the expired and obsolete
(files which have no active references to) mob files.
Periodic MOB compaction chore.
The mob file name.
A filter that returns the cells which have mob reference tags.
Scans a given table + CF for all mob reference cells to get the list of backing mob files.
MobStoreEngine creates the mob specific compactor, and store flusher.
Scanner scans both the memstore and the MOB Store.
The mob utilities
Represents a display mode in the top screen.
The presentation logic for the mode screen.
The screen where we can choose the
Mode in the top screen.An interface for strategy logic for
Mode.The procedure to add a namespace to an existing table.
The base class for all replication peer related procedure except sync replication state
transition.
Utility methods for interacting with the regions.
This procedure is used to change the store file tracker implementation.
The procedure will only update the table descriptor without reopening all the regions.
A MonitoredTask implementation optimized for use with RPC Handlers handling frequent, short
duration tasks.
A MonitoredTask implementation designed for use with RPC Handlers handling frequent, short
duration tasks.
Given the starting state of the regions and a potential ending state compute cost based upon the
number of regions that have moved.
Deprecated.
Do not use any more.
Move Regions and make sure that they are up on the target server.If a region movement fails we
exit as failure
Move Regions without Acknowledging.Usefule in case of RS shutdown as we might want to shut the RS
down anyways and not abort on a stuck region.
The purpose of introduction of
MovingAverage mainly is to measure execution time of a
specific method, which can help us to know its performance fluctuation in response to different
machine states or situations, better case, then to act accordingly.Exception thrown when the result needs to be chunked on the server side.
Provides a unified view of all the underlying ByteBuffers and will look as if a bigger sequential
buffer.
This filter is used for selecting only those keys with columns that matches a particular prefix.
A container for Result objects, grouped by regionName.
This class implements atomic multi row transactions using
HRegion.mutateRowsWithLocks(Collection, Collection, long, long) and Coprocessor
endpoints.Filter to support scan multiple row key ranges.
Abstraction over the ranges of rows to return from this filter, regardless of forward or
reverse scans being used.
Internal RowRange that reverses the sort-order to handle reverse scans.
Create 3 level tree directory, first level is using table name as parent directory and then use
family name as child directory, and all related HFiles for one family are under child directory
-tableName1 -columnFamilyName1 -columnFamilyName2 -HFiles -tableName2 -columnFamilyName1 -HFiles
-columnFamilyName2
Convert HBase tabular data from multiple scanners into a format that is consumable by Map/Reduce.
A base for
MultiTableInputFormats.
Hadoop output format that writes to one or more HBase tables.
Record writer for outputting to multiple HTables.
MultiTableSnapshotInputFormat generalizes
TableSnapshotInputFormat allowing a MapReduce job to run
over one or more table snapshots, with one or more scans configured for each.MultiTableSnapshotInputFormat generalizes
TableSnapshotInputFormat allowing a MapReduce
job to run over one or more table snapshots, with one or more scans configured for each.Shared implementation of mapreduce code over multiple table snapshots.
Example on how to use HBase's
Connection and Table in a multi-threaded
environment.Class to show how to scan some rows starting at a random location.
Class to show how to send a single put.
Class that will show how to send batches of puts at the same time.
Multithreaded implementation for @link org.apache.hbase.mapreduce.TableMapper
Manages the read/write consistency.
Write number and whether write has completed given out at start of a write transaction.
Computes the optimal (minimal cost) assignment of jobs to workers (or other analogous) concepts
given a cost matrix of each pair of job and worker, using the algorithm by James Munkres in
"Algorithms for the Assignment and Transportation Problems", with additional optimizations as
described by Jin Kue Wong in "A New Implementation of an Algorithm for the Optimal Assignment
Problem: An Improved Version of Munkres' Algorithm".
This is a very fast, non-cryptographic hash suitable for general hash-based lookup.
This is a very fast, non-cryptographic hash suitable for general hash-based lookup.
A histogram implementation that runs in constant space, and exports to hadoop2's metrics2 system.
Interface to Map of online regions.
Extended histogram implementation with metric range counters.
An implementation of RegionInfo that adds mutable methods so can build a RegionInfo instance.
A mutable segment in memstore, specifically the active segment.
Extended histogram implementation with counters for metric size ranges.
Extended histogram implementation with counters for metric time ranges.
Request object to be used by ring buffer use-cases.
Response object to be sent by namedQueue service back to caller
Base payload to be prepared by client to send various namedQueue events for in-memory ring buffer
storage in either HMaster or RegionServer.
NamedQueue recorder that maintains various named queues.
In-memory Queue service provider for multiple use-cases.
Chore to insert multiple accumulated slow/large logs to hbase:slowlog system table
The Class NamespaceAuditor performs checks to ensure operations like table creation and region
splitting preserve namespace quota.
Namespace POJO class.
Thrown when a namespace exists but should not
A WAL grouping strategy based on namespace.
Implementation for
ModeStrategy for Namespace Mode.Thrown when a namespace can not be located
Represents an authorization for access for the given namespace.
QuotaSnapshotStore implementation for namespaces.List a HBase namespace's key/value properties.
Implements the following REST end points:
A list of HBase namespaces.
Implements REST GET list of all namespaces.
NamespaceStateManager manages state (in terms of quota) of all the namespaces.
NamespaceTableAndRegionInfo is a helper class that contains information about current state of
tables and regions in a namespace.
Filter a WAL Entry by the peer config according to the table and family which it belongs to.
Helper class for passing netty event loop config to
AsyncFSWALProvider.Event loop group related config.
Helper class for processing netty futures.
Implement logic to deal with the rpc connection header.
Implement SASL logic for netty rpc client.
Implement SASL logic for netty rpc client.
Implement SASL negotiation logic for rpc server.
Netty client for the requests and responses.
Helper class for passing config to
NettyRpcClient.RPC connection implementation based on netty.
The netty rpc handler.
Decoder for extracting frame
An RPC server with Netty4 implementation.
Handler to enforce writability protections on our server channels:
- Responds to channel writability events, which are triggered when the total pending bytes for a channel passes configured high and low watermarks.
- Responds to channel writability events, which are triggered when the total pending bytes for a channel passes configured high and low watermarks.
Handle connection preamble.
Decoder for rpc request.
Encoder for
RpcResponse.Datastructure that holds all necessary to a method invocation and then afterward, carries the
result.
RpcConnection implementation for netty rpc server.
Wraps some usages of netty's unsafe API, for ease of maintainability.
A tracker both implementing ColumnTracker and DeleteTracker, used for mvcc-sensitive scanning.
A
SpaceViolationPolicyEnforcement which disallows any inserts to the table.This is a special
ScannerContext subclass that is designed to be used globally when
limits should not be enforced during invocations of InternalScanner.next(java.util.List)
or InternalScanner.next(java.util.List).NonceGenerator interface.
This implementation is not smart and just treats nonce group and nonce as random bits.
A "non-lazy" scanner which always does a real seek operation.
Used internally signaling failed queue of a remote procedure operation.
A "non-reversed & non-lazy" scanner which does not support backward scanning and always does
a real seek operation.
Accounting of current heap and data sizes.
NoopAccessChecker is returned when hbase.security.authorization is not enabled.
Does not perform any kind of encoding/decoding.
Does not perform any kind of encoding/decoding.
Noop operation quota returned when no quota is associated to the user/table
An In-Memory store that does not keep track of the procedures inserted.
Noop quota limiter returned when no limiter is associated to the user/table
A
RegionSizeStore implementation that stores nothing.A
RegionSplitRestriction implementation that does nothing.A
NormalizationPlan describes some modification to region split points as identified by
an instance of RegionNormalizer.A POJO that caries details about a region selected for normalization through the pipeline.
A collection of criteria used for table selection.
Used to instantiate an instance of
NormalizeTableFilterParams.Query matcher for normal user scan.
Used internally signaling failed queue of a remote procedure operation.
Thrown when no region server can be found for a region
Thrown if request for nonexistent column family.
ByteBuffer based cell which has the chunkid at the 0th offset and with no tags
An extension of the ByteBufferKeyValue where the tags length is always 0
An extension of the KeyValue where the tags length is always 0
Thrown when an operation requires the root and all meta regions to be online
Thrown by a region server if it is sent a request for a region it is not serving.
A
SpaceViolationPolicyEnforcement implementation which disables all updates and
compactions.A
SpaceViolationPolicyEnforcement implementation which disables all writes flowing into
HBase.A binary comparator which lexicographically compares against the specified byte array using
Bytes.compareTo(byte[], byte[]).Used internally signaling failed queue of a remote procedure operation.
A generic class for pair of an Object and and a primitive int value.
A thread-safe shared object pool in which object creation is expected to be lightweight, and the
objects may be excessively created and discarded.
An
ObjectFactory object is used to create new shared objects on demand.Carries the execution state for a given invocation of an Observer coprocessor
(
RegionObserver, MasterObserver, or WALObserver) method.This is the only implementation of
ObserverContext, which serves as the interface for
third-party Coprocessor developers.An off heap chunk implementation.
This chore is used to update the 'oldWALsDirSize' variable in
MasterWalManager through
the MasterWalManager.updateOldWALsDirSize() method.An on heap chunk implementation.
Slow/Large Log payload for hbase-client, to be used by Admin API get_slow_responses and
get_large_responses
Provides read-only access to the Regions presently online on the current RegionServer
Handles opening of a meta region on a region server.
Handles opening of a high priority region on a region server.
Deprecated.
Keep it here only for compatible
Thread to run region post open tasks.
The remote procedure used to open a region.
Superclass for any type that maps to a potentially application-level query.
Container class for commonly collected metrics for most operations.
Interface that allows to check the quota available for an operation.
This class stores the Operation status code and the exception message that occurs in case of
failure of operations like put, delete, etc.
Used to describe or modify the lexicographical sort order of a
byte[].A
byte[] of variable-length.An alternative to
OrderedBlob for use by Struct fields that do not terminate the
fields list.Utility class that handles ordered byte arrays.
Base class for data types backed by the
OrderedBytes encoding implementations.A
float of 32-bits using a fixed-length encoding.A
double of 64-bits using a fixed-length encoding.A
short of 16-bits using a fixed-length encoding.An
int of 32-bits using a fixed-length encoding.A
long of 64-bits using a fixed-length encoding.A
byte of 8-bits using a fixed-length encoding.An
Number of arbitrary precision and variable-length encoding.A
String of variable-length.Thrown by a RegionServer while doing next() calls on a ResultScanner.
The following class is an abstraction class to provide a common interface to support different
ways of consuming recovered edits.
This is a dummy annotation that forces javac to produce output for otherwise empty
package-info.java.
Implementation of Filter interface that limits results to a specific page size.
Utility class for paging for the metrics.
A generic class for pairs.
A generic, immutable class for pairs of objects both of type
T.Handler to seek storefiles in parallel.
ParseConstants holds a bunch of constants related to parsing Filter Strings Used by
ParseFilterThis class allows a user to specify a filter via a string The string is parsed using the methods
of this class and a filter object is constructed.
An example for using protobuf objects with
DataType API.A base-class for
DataType implementations backed by protobuf.Get notification for replication peer events.
A handler for modifying replication peer in peer procedures.
Implementation of
FileKeyStoreLoader that loads from PEM files.This file has been copied from the Apache ZooKeeper project.
Placeholder of a watcher which might be triggered before the instance is not yet created.
NonceGenerator implementation that uses client ID hash + random int as nonce group, and random
numbers as nonces.
Base permissions instance representing the ability to perform a given set of actions.
Maintains lists of permission grants to users and groups to allow for authorization checks by
AccessController.A class implementing PersistentIOEngine interface supports file integrity verification for
BucketCache which use persistent IOEngineImplementation of
FileKeyStoreLoader that loads from PKCS12 files.An adapter between Jersey and Object.toString().
This exception is thrown by the master when a region server was shut down and restarted so fast
that the master still hasn't processed the server shutdown of the first instance, or when master
is initializing and client call admin operations, or when an operation is performed on a region
server that is still starting.
Thrown if the master requires restart.
Abstract class template for defining a pluggable blocking queue implementation to be used by the
'pluggable' call queue type in the RpcExecutor.
Internal runtime error type to indicate the RpcExecutor failed to execute a `pluggable` call
queue type.
The
PoolMap maps a key to a collection of values, the elements of which are managed
by a pool.
Extends
ByteRange with additional methods to support tracking a consumers position within
the viewport.Used to decode preamble calls.
Deprecated.
since 2.3.0, and will be removed in 4.0.0.
Class to submit requests for PrefetchExecutor depending on configuration change
Pass results that have same row prefix.
Compress key by storing size of common prefix with previous KeyValue and storing raw size of
rest.
A throughput controller which uses the follow schema to limit throughput
If compaction pressure is greater than 1.0, no limitation.
In off peak hours, use a fixed throughput limitation
"hbase.hstore.compaction.throughput.offpeak"
In normal hours, the max throughput is tuned between
"hbase.hstore.compaction.throughput.lower.bound" and
"hbase.hstore.compaction.throughput.higher.bound", using the formula "lower +
(higer - lower) * compactionPressure", where compactionPressure is in range [0.0, 1.0]
A throughput controller which uses the follow schema to limit throughput
If flush pressure is greater than or equal to 1.0, no limitation.
In normal case, the max throughput is tuned between
"hbase.hstore.flush.throughput.lower.bound" and
"hbase.hstore.flush.throughput.upper.bound", using the formula "lower + (upper -
lower) * flushPressure", where flushPressure is in range [0.0, 1.0)
Stores the information of one controlled compaction.
Tool for validating that cluster can be upgraded from HBase 1.x to 2.0
This BlockCompressedSizePredicator implementation adjusts the block size limit based on the
compression rate of the block contents read so far.
Compute the cost of a potential cluster state from skew in number of primary regions on a
cluster.
Function to figure priority of incoming request.
Utility methods helpful slinging
Cell instances.These cells are used in reseeks/seeks to improve the read performance.
These cells are used in reseeks/seeks to improve the read performance.
This can be used when a Cell has to change with addition/removal of one or more tags.
Constants intended to be used internally.
A globally-barriered distributed procedure.
Base Procedure class responsible for Procedure Metadata; e.g.
Thrown when a procedure is aborted
This is the master side of a distributed complex procedure execution.
RPCs for the coordinator to run a barriered procedure with subprocedures executed at distributed
members.
Type class.
Basic ProcedureEvent that contains an "object", which can be a description or a reference to the
resource to wait on, and a queue for suspended procedures.
Thread Pool that executes the submitted procedures.
Class with parameters describing how to fail/die when in testing-context.
A helper class for switching procedure out(yielding) while it is doing some time consuming
operation, such as updating meta, where we can get a
CompletableFuture about the
operation.Special procedure used as a chore.
Provides the common setup framework and runtime services for globally barriered procedure
invocation from HBase services.
Process to kick off and manage a running
Subprocedure on a member.This is the notification interface for Procedures that encapsulates message passing from members
to a coordinator.
With this interface, the procedure framework provides means to collect following set of metrics
per procedure type for all procedures:
Count of submitted procedure instances
Time histogram for successfully completed procedure instances
Count of failed procedure instances
Please implement this interface to return appropriate metrics.
Latch used by the Master to have the prepare() sync behaviour for old clients, that can only get
exceptions in a synchronous way.
Keep track of the runnable procedures
Construct a
Span instance for a Procedure execution.The ProcedureStore is used by the executor to persist the state of each procedure execution.
An Iterator over a collection of Procedure
Interface passed to the ProcedureStore.load() method to handle the store-load events.
Store listener interface.
Base class for
ProcedureStores.Deprecated.
Since 2.3.0, will be removed in 4.0.0.
Helper to synchronously wait on conditions.
Used to build the tree for procedures.
Helper to convert to/from ProcedureProtos
A serializer (deserializer) for those Procedures which were serialized before this patch.
A serializer for our Procedures.
Deprecated.
Since 2.3.0, will be removed in 4.0.0.
Deprecated.
Since 2.3.0, will be removed in 4.0.0.
Deprecated.
Since 2.3.0, will be removed in 4.0.0.
Deprecated.
Since 2.3.0, will be removed in 4.0.0.
Indicate that a procedure wants to be rescheduled.
Process related utilities.
Servlet to serve files generated by
ProfileServletServlet that runs async-profiler as web-endpoint.
This extension to ConfigurationObserver allows the configuration to propagate to the children of
the current
ConfigurationObserver.when loading we will iterator the procedures twice, so use this class to cache the deserialized
result to prevent deserializing multiple times.
Modified based on io.netty.handler.codec.protobuf.ProtobufDecoder.
Writer for protobuf-based WAL.
Adapter for hooking up Jersey content processing dispatch to ProtobufMessageHandler interface
capable handlers for decoding protobuf input.
An adapter between Jersey and ProtobufMessageHandler implementors.
Common interface for models capable of supporting protobuf marshalling and unmarshalling.
A one way stream reader for reading protobuf based WAL file.
A WAL reader for replication.
This file has been copied directly (changing only the package name and and the ASF license text
format, and adding the Yetus annotations) from Hadoop, as the Hadoop version that HBase depends
on doesn't have it yet (as of 2020 Apr 24, there is no Hadoop release that has it either).
Used to perform Put operations for a single row.
Combine Puts.
Emits sorted Puts.
Annotation which decorates RPC methods to denote the relative priority among other RPCs in the
same server.
This filter is used to filter based on the column qualifier.
Base class for HBase read operations; e.g.
Interface for balancing requests across IPC queues
Cache that keeps track of the quota settings for the users and tables that are interacting with
it.
Generic quota exceeded exception
Filter to use to filter the QuotaRetriever results.
Internal interface used to interact with the user/table quota.
Reads the currently received Region filesystem-space use reports and acts on those which violate
a defined quota.
A container which encapsulates the tables that have either a table quota or are contained in a
namespace which have a namespace quota.
Scanner to iterate over the quota settings.
Describe the Scope of the quota rules.
A common interface for computing and storing space quota observance/violation for entities.
In-Memory state of table or namespace quotas
Helper class to interact with the quota table.
Describe the Quota Type.
Helper class to interact with the quota table
Wrapper over the rack resolution utility in Hadoop.
An instance of this class is used to generate a stream of pseudorandom numbers.
Queue balancer that just randomly selects a queue in the range [0, num queues).
A filter that includes rows based on a chance.
Simple rate limiter.
The default algorithm for selecting files for compaction.
The implementation of AsyncAdmin.
The implementation of RawAsyncTable.
An
DataType for interacting with values encoded using
Bytes.putByte(byte[], int, byte).An
DataType for interacting with variable-length values encoded using
Bytes.putBytes(byte[], int, byte[], int, int).An
DataType that encodes fixed-length values encoded using
Bytes.putBytes(byte[], int, byte[], int, int).An
DataType that encodes variable-length values encoded using
Bytes.putBytes(byte[], int, byte[], int, int).An extended version of Cell that allows CPs manipulate Tags.
Allows creating a cell with
Tag An instance of this type can be acquired by using
RegionCoprocessorEnvironment#getCellBuilder (for prod code) and RawCellBuilderFactory
(for unit tests).Factory for creating cells for CPs.
An
DataType for interacting with values encoded using
Bytes.putDouble(byte[], int, double).An
DataType for interacting with values encoded using
Bytes.putFloat(byte[], int, float).An
DataType for interacting with values encoded using
Bytes.putInt(byte[], int, int).An
DataType for interacting with values encoded using
Bytes.putLong(byte[], int, long).Query matcher for raw scan.
An
DataType for interacting with values encoded using
Bytes.putShort(byte[], int, short).An
DataType for interacting with values encoded using Bytes.toBytes(String).An
DataType that encodes fixed-length values encoded using
Bytes.toBytes(String).An
DataType that encodes variable-length values encoded using
Bytes.toBytes(String).Carries the information on some of the meta data about the HFile Reader
A builder that helps in building up the ReaderContext
Exception thrown when a read only byte range is modified
Wraps a Configuration to make it read-only.
A very simple read only zookeeper implementation without watcher support.
Lock to manage concurrency between
RegionScanner and
HRegion.getSmallestReadPoint().Compute the cost of total number of read requests The more unbalanced the higher the computed
cost will be.
Represents a record of the metrics in the top screen.
Represents a filter that's filtering the metric
Records.A zookeeper that can handle 'recoverable' errors.
Class that manages the output streams from the log splitting process.
Class that handles the recovered source of a replication stream, which is transfered from another
dead region server.
Used by a
RecoveredReplicationSource.Utility methods for recovering file lease for hdfs.
Deprecated.
Do not use any more, leave it here only for compatible.
The procedure for replaying all the remote wals for transitting a sync replication peer from
STANDBY to DOWNGRADE_ACTIVE.
Maintain an reference count integer inside to track life cycle of
ByteBuff, if the
reference count become 0, it'll call ByteBuffAllocator.Recycler.free() exactly once.A map of K to V, but does ref counting for added and removed values.
A reference to the top or bottom half of a store file where 'bottom' is the first half of the
file containing the keys that sort lowest and 'top' is the second half of the file with keys that
sort greater than those of the bottom half.
For split HStoreFiles, it specifies if the file covers the lower half or the upper half of the
key range
Cache to hold resolved Functions of a specific signature, generated through reflection.
This client class is for invoking the refresh HFile function deployed on the Region Server side
via the RefreshHFilesService.
Coprocessor endpoint to refresh HFiles on replica.
The callable executed at RS side to refresh the peer config/state.
This comparator is for use with
CompareFilter implementations, such as RowFilter,
QualifierFilter, and ValueFilter, for filtering based on the value of a given
column.This is an internal interface for abstracting access to different regular expression matching
engines.
Engine implementation type (default=JAVA)
Implementation of the Engine interface using Java's Pattern.
Implementation of the Engine interface using Jruby's joni regex engine.
Region is a subset of HRegion with operations required for the
Coprocessors.Operation enum is used in
Region.startRegionOperation() and elsewhere to provide context
for various checks.Row lock held by a given thread.
Implements the coprocessor environment and runtime support for coprocessors loaded within a
Region.Encapsulation of the environment of each coprocessor
Special version of RegionEnvironment that exposes RegionServerServices for Core Coprocessors
only.
The implementation of a region based coprocessor rpc channel.
Represents a coprocessor service method execution against a single region.
Compute the cost of a potential cluster state from skew in number of regions on a cluster.
Thrown when something happens related to region handling.
A WAL Provider that returns a WAL per group of regions.
Map identifiers to a group number.
Maps between configuration names for strategies and implementation classes.
This will find where data for a region is located in HDFS.
Information about a region.
The following comparator assumes that RegionId from HRegionInfo can represent the age of the
region - larger RegionId means the region is younger.
Utility used composing RegionInfo for 'display'; e.g.
POJO representing region server load
Indicate which row you want to locate.
Container for holding a list of
HRegionLocation's that correspond to the same range.Used to view region location information for a single HBase table.
The
RegionLocator implementation based on AsyncTableRegionLocator.Encapsulates per-region load metrics.
Implementation for
ModeStrategy for Region Mode.Subclass if the server knows the region is now on another server.
Tool for loading/unloading regions to/from given regionserver This tool can be run from Command
line directly as a utility.
Builder for Region mover.
Performs "normalization" of regions of a table, 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.
Chore that will periodically call
HMaster.normalizeRegions(NormalizeTableFilterParams, boolean).Factory to create instance of
RegionNormalizer as configured.This class encapsulates the details of the
RegionNormalizer subsystem.Store region normalizer state.
Consumes normalization request targets (
TableNames) off the
RegionNormalizerWorkQueue, dispatches them to the RegionNormalizer, and executes
the resulting NormalizationPlans.A specialized collection that holds pending work for the
RegionNormalizerWorker.Coprocessors implement this interface to observe and mediate client actions on the region.
Mutation type for postMutationBeforeWAL hook
Thrown when a table can not be located
Subclass if the server knows the region is now on another server.
A tool that is used for manipulating and viewing favored nodes information for regions.
Some algorithms for solving the assignment problem may traverse workers or jobs in linear order
which may result in skewing the assignments of the first jobs in the matrix toward the last
workers in the matrix if the costs are uniform.
Stores the plan for the move of an individual region.
A procedure store which uses the master local store to store all the procedures.
The base class for the remote procedures used to open/close a region.
Generates candidates which moves the replicas out of the region server for co-hosted region
replicas
HBASE-11580: With the async wal approach (HBASE-11568), the edits are not persisted to WAL in
secondary region replicas.
A cost function for region replicas.
A cost function for region replicas.
A POJO that consolidates the information about a single region replica that's stored in meta.
Generates candidates which moves the replicas out of the rack for co-hosted region replicas in
the same rack
A cost function for region replicas for the rack distribution.
Manager the buffer size for all